Java中IO流 字节流实例详解
Java中IO流字节流实例详解
IO流（输入流、输出流），又分为字节流、字符流。
流是磁盘或其它外围设备中存储的数据的源点或终点。
输入流：程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道。
输出流：程序向输出流写入数据。将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道。
字节流
1.InputStream、OutputStream
InputStream抽象了应用程序读取数据的方式
OutputStream抽象了应用程序写出数据的方式
2.读到文件结尾，称为EOF=end，读到-1就读到结尾
3.输入流基本方法
intb=in.read();读取一个字节，无符号填充到int的低八位.-1是EOF
int.read(byte[]buf)读取数据填充到字节数组buf
int.read(byte[]buf,intstart,intsize)读取数据填充到字节数组buf，从buf的start位置开始存储size长度的数据
4.输出流基本方法
out.write(intb);写出一个byte到流，b的低八位
out.write(byte[]buf);将buf字节数组都写入到流
out.write(byte[]buf,intstart,intsize);字节数组buf从start位置开始写size长度的字节到流
5.FileInputStream是InputStream的子类，具体实现了在文件上读取数据
6.FileOutputStream是OutputStream的子类，实现了向文件中写出字节数据的方法
FileInputStream的demo：
packagecom.test.io;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
publicclassIOUtils{
/**
*读取指定文件内容，按照十六进制输出到控制台
*并且每输出10个byte换行
*@paramfileName
*@throwsIOException
*/
publicstaticvoidprintHex(StringfileName)throwsIOException{
//把文件作为字节流进行读操作
FileInputStreamin=newFileInputStream(fileName);
intb;
inti=1;
while((b=in.read())!=-1){
if(b<=0xf){
System.out.print("0");
}
System.out.print(Integer.toHexString(b)+"");
if(i%10==0){
System.out.println("");
}
i++;
}
in.close();
}
publicstaticvoidprintHexByByteArray(StringfileName)throwsIOException{
FileInputStreamin=newFileInputStream(fileName);
byte[]buf=newbyte[20*1024];
//如果字节数组够大，可以一次性读完
//从in中批量读取字节，放入到buf这个字节数组中，从第0个位置开始放，最多放buf.length个，返回的是读到的字节的个数
/*intbytes=in.read(buf,0,buf.length);
intj=1;
for(inti=0;i
FileOutputStream的demo：
packagecom.test.io;
importjava.io.FileOutputStream;
importjava.io.IOException;
publicclassFileOutputDemo{
publicstaticvoidmain(String[]args)throwsIOException{
//如果该文件不存在，则直接创建，如果存在，删除后创建。（如果第二个参数为true，则将字节写入文件末尾处，而不是写入文件开始处。）
FileOutputStreamout=newFileOutputStream("F:\\javaio\\out.dat");
out.write('A');//写入了‘A'的低八位（一次只写入一个字节）
inta=10;
out.write(a>>>24);
out.write(a>>>16);
out.write(a>>>8);
out.write(a);
byte[]b="10".getBytes();
out.write(b);
out.close();
IOUtils.printHex("F:\\javaio\\out.dat");
}
}
7.DataOutputStream和DataInputStream，对流功能的扩展，可以更加方便的读取int，long，字符等类型数据。
packagecom.test.io;
importjava.io.DataOutputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
publicclassDataOutputDemo{
publicstaticvoidmain(String[]args)throwsIOException{
Stringfile="F:\\javaio\\b.txt";
DataOutputStreamdos=newDataOutputStream(newFileOutputStream(file));
dos.writeInt(10);
dos.writeInt(-10);
dos.writeLong(10l);
dos.writeDouble(10.5);
dos.writeUTF("你好");
dos.writeChars("中国");
dos.close();
IOUtils.printHex(file);
}
}
运行结果：
0000000afffffff60000
00000000000a40250000
000000000006e4bda0e5
a5bd4e2d56fd
其中，0006两个字节是“你好”这两个中文的字节个数。
packagecom.test.io;
importjava.io.DataInputStream;
importjava.io.FileInputStream;
importjava.io.IOException;
publicclassDataInputDemo{
publicstaticvoidmain(String[]args)throwsIOException{
Stringfile="F:\\javaio\\b.txt";
DataInputStreamdis=newDataInputStream(newFileInputStream(file));
inti=dis.readInt();
System.out.println(i);
i=dis.readInt();
System.out.println(i);
longl=dis.readLong();
System.out.println(l);
doubled=dis.readDouble();
System.out.println(d);
Strings=dis.readUTF();
System.out.println(s);
dis.close();
}
}
运行结果：
10
-10
10
10.5
你好
8.BufferedInputStream&BufferedOutputStream，这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能。
文件的拷贝：
packagecom.test.io;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
publicclassIOUtils{/**
*拷贝文件,字节批量读取
*@paramsrcFile源文件
*@paramdestFile目标文件
*@throwsIOException
*/
publicstaticvoidcopyFile(FilesrcFile,FiledestFile)throwsIOException{
if(!srcFile.exists()){
thrownewIllegalArgumentException("文件"+srcFile+"不存在");
}
if(!srcFile.isFile()){
thrownewIllegalArgumentException(srcFile+"不是文件");
}
FileInputStreamin=newFileInputStream(srcFile);
FileOutputStreamout=newFileOutputStream(destFile);
byte[]buf=newbyte[10*1024];
intb;
while((b=in.read(buf,0,buf.length))!=-1){
out.write(buf,0,b);
out.flush();//最好加上，刷新此输出流并强制写出所有缓冲的输出字节。
}
in.close();
out.close();
}
/**
*拷贝文件，利用带缓冲的字节流
*@paramsrcFile
*@paramdestFile
*@throwsIOException
*/
publicstaticvoidcopyFileByBuffer(FilesrcFile,FiledestFile)throwsIOException{
if(!srcFile.exists()){
thrownewIllegalArgumentException("文件"+srcFile+"不存在");
}
if(!srcFile.isFile()){
thrownewIllegalArgumentException(srcFile+"不是文件");
}
FileInputStreamin=newFileInputStream(srcFile);
FileOutputStreamout=newFileOutputStream(destFile);
BufferedInputStreambis=newBufferedInputStream(in);
BufferedOutputStreambos=newBufferedOutputStream(out);
intc;
while((c=bis.read())!=-1){
bos.write(c);
bos.flush();
}
bis.close();
bos.close();
}
/**
*拷贝文件，通过单字节读取
*@paramsrcFile
*@paramdestFile
*@throwsIOException
*/
publicstaticvoidcopyFileByByte(FilesrcFile,FiledestFile)throwsIOException{
if(!srcFile.exists()){
thrownewIllegalArgumentException("文件"+srcFile+"不存在");
}
if(!srcFile.isFile()){
thrownewIllegalArgumentException(srcFile+"不是文件");
}
FileInputStreamin=newFileInputStream(srcFile);
FileOutputStreamout=newFileOutputStream(destFile);
intc;
while((c=in.read())!=-1){
out.write(c);
out.flush();
}
in.close();
out.close();
}
}
测试文件拷贝：
packagecom.test.io;
importjava.io.File;
importjava.io.IOException;
publicclassIOUtilsTest{
publicstaticvoidmain(String[]args){
//IOUtils.printHex("D:\\javaProgram\\Hello.java");
try{
longstart=System.currentTimeMillis();
//IOUtils.copyFile(newFile("F:\\javaio\\1.mp3"),newFile("F:\\javaio\\2.mp3"));//211ms
//IOUtils.copyFileByBuffer(newFile("F:\\javaio\\1.mp3"),newFile("F:\\javaio\\3.mp3"));//18583ms
IOUtils.copyFileByByte(newFile("F:\\javaio\\1.mp3"),newFile("F:\\javaio\\4.mp3"));//37822ms
longend=System.currentTimeMillis();
System.out.println(end-start);
}catch(IOExceptione){
e.printStackTrace();
}
}
}
根据以上测试看出，文件拷贝，最快的方式是通过字节的批量读取。
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！