Java IO之包装流详解

Java IO之包装流详解

目录1、前面讲的字符输入输出流，字节输入输出流都是字节流。那么什么是包装流呢？2、缓冲流　　3、转换流：把字节流转换为字符流4、内存流（数组流）：5、合并流：把多个输入流合并为一个流，也叫顺序流，因为在读取的时候是先读第一个，读完了在读下面一个流。总结

根据功能分为节点流和包装流（处理流）

节点流：可以从或向一个特定的地方(节点)读写数据。如FileReader.

处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

1、前面讲的字符输入输出流，字节输入输出流都是字节流。那么什么是包装流呢？

①、包装流隐藏了底层节点流的差异，并对外提供了更方便的输入\输出功能，让我们只关心这个高级流的操作

②、使用包装流包装了节点流，程序直接操作包装流，而底层还是节点流和IO设备操作

③、关闭包装流的时候，只需要关闭包装流即可

2、缓冲流

缓冲流：是一个包装流，目的是缓存作用，加快读取和写入数据的速度。

字节缓冲流：BufferedInputStream、BufferedOutputStream

字符缓冲流：BufferedReader、BufferedWriter

案情回放：我们在将字符输入输出流、字节输入输出流的时候，读取操作，通常都会定义一个字节或字符数组，将读取/写入的数据先存放到这个数组里面，然后在取数组里面的数据。这比我们一个一个的读取/写入数据要快很多，而这也就是缓冲流的由来。只不过缓冲流里面定义了一个 数组用来存储我们读取/写入的数据，当内部定义的数组满了（注意：我们操作的时候外部还是会定义一个小的数组，小数组放入到内部数组中），就会进行下一步操作。

下面是没有用缓冲流的操作：

//1、创建目标对象，输入流表示那个文件的数据保存到程序中。不写盘符，默认该文件是在该项目的根目录下

//a.txt 保存的文件内容为：AAaBCDEF

File target = new File("io"+File.separator+"a.txt");

//2、创建输入流对象

InputStream in = new FileInputStream(target);

//3、具体的 IO 操作（读取 a.txt 文件中的数据到程序中）

/**

* 注意：读取文件中的数据，读到最后没有数据时，返回-1

* int read():读取一个字节，返回读取的字节

* int read(byte[] b):读取多个字节,并保存到数组 b 中，从数组 b 的索引为 0 的位置开始存储，返回读取了几个字节

* int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中，从数组b 的索引为 0 的位置开始，长度为len个字节

*/

//int read():读取一个字节，返回读取的字节

int data1 = in.read();//获取 a.txt 文件中的数QRjdWM据的第一个字节

System.out.println((char)data1); //A

//int read(byte[] b):读取多个字节保存到数组b 中

byte[] buffer = new byte[10];//这里我们定义了一个 长度为 10 的字节数组，用来存储读取的数据

in.read(buffer);//获取 a.txt 文件中的前10 个字节，并存储到 buffer 数组中

System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 67, 68, 69, 70, 0, 0, 0]

System.out.println(new String(buffer)); //AaBCDEF[][][]

//int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中,从索引 off 开始到 len

in.read(buffer, 0, 3);

System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 0, 0, 0, 0, 0, 0, 0]

System.out.println(new String(buffer)); //AaB[][][][][][][]

//4、关闭流资源

in.close();

我们查看 缓冲流的 JDK 底层源码，可以看到，程序中定义了这样的 缓存数组,大小为 8192

BufferedInputStream:

BufferedOutputStream:

//字节缓冲输入流

BufferedInputStream bis = new BufferedInputStream(

new FileInputStream("io"+File.separator+"a.txt"));

//定义一个字节数组，用来存储数据

byte[] buffer = new byte[1024];

int len = -1;//定义一个整数，表示读取的字节数

while((len=bis.read(buffer))!=-1){

System.out.println(new String(buffer,0,len));

}

//关闭流资源

bis.close();

//字节缓冲输出流

BufferedOutputStream bos = new BufferedOutputStream(

new FileOutputStream("io"+File.separator+"a.txt"));

bos.write("ABCD".getBytes());

bos.close();

//字符缓冲输入流

BufferedReader br = new BufferedReader(

new FileReader("io"+File.separator+"a.txt"));

char[] buffer = new char[10];

int len = -1;

while((len=br.read(buffer))!=-1){

System.out.println(new String(buffer,0,len));

}

br.close();

//字符缓冲输出流

BufferedWriter bw = new BufferedWriter(

new FileWriter("io"+File.separator+"a.txt"));

bw.write("ABCD");

bw.close();

3、转换流：把字节流转换为字符流

InputStreamReader:把字节输入流转换为字符输入流

OutputStreamWriter:把字节输出流转换为字符输出流

用转换流进行文件的复制：

/**

* 将 a.txt 文件 复制到 b.txt 中

*/

//1、创建源和目标

File srcFile = new File("io"+File.separator+"a.txt");

File descFile = new File("io"+File.separator+"b.txt");

//2、创建字节输入输出流对象

InputStream in = new FileInputStream(srcFile);

OutputStream out = new FileOutputStream(descFile);

//3、创建转换输入输出对象

Reader rd = new InputStreamReader(in);

Writer wt = new OutputStreamWriter(out);

//3、读取和写入操作

char[] buffer = new char[10];//创建一个容量为 10 的字符数组，存储已经读取的数据

int len = -1;//表示已经读取了多少个字符，如果是 -1，表示已经读取到文件的末尾

while((len=rd.read(buffer))!=-1){

wt.write(buffer, 0, len);

}

//4、关闭流资源

rd.close();

wt.close();

4、内存流（数组流）：

把数据先临时存在数组中，也就是内存中。所以关闭 内存流是无效的，关闭后还是可以调用这个类的方法。底层源码的 close()是一个空方法

①、字节内存流：ByteArrayOutputStream 、ByteArrayInputStream

//字节数组输出流：程序---》内存

ByteArrayOutputStream bos = new ByteArrayOutputStream();

//将数据写入到内存中

bos.write("ABCD".getBytes());

//创建一个新分配的字节数组。 其大小是此输出流的当前大小，缓冲区的有效内容已被复制到其中。

byte[] temp = bos.toByteArray();

System.out.println(new String(temp,0,temp.length));

byte[] buffer = new byte[10];

///字节数组输入流：内存---》程序

ByteArrayInputStream bis = new ByteArrayInputStream(temp);

int len = -1;

while((len=bis.read(buffer))!=-1){

System.out.println(new String(buffer,0,len));

}

//这里不写也没事，因为源码中的 close()是一个空的方法体

bos.close();

bis.close();

②、字符内存流：CharArrayReader、CharArrayWriter

//字符数组输出流

CharArrayWriter caw = new CharArrayWriter();

caw.write("ABCD");

//返回内存数据的副本

char[] temp = caw.toCharArray();

System.out.println(new String(temp));

//字符数组输入流

CharArrayReader car = new CharArrayReader(temp);

char[] buffer = new char[10];

int len = -1;

while((len=car.read(buffer))!=-1){

System.out.println(new String(buffer,0,len));

}

③、字符串流：StringReader,StringWriter（把数据临时存储到字符串中）

//字符串输出流,底层采用 StringBuffer 进行拼接

StringWriter sw = new StringWriter();

sw.write("ABCD");

sw.write("帅锅");

System.out.println(sw.toString());//ABCD帅锅

//字符串输入流

StringReader sr = new StringReader(sw.toString());

char[] buffer = new char[10];

int len = -1;

while((len=sr.read(buffer))!=-1){

System.out.println(new String(buffer,0,len));//ABCD帅锅

}

5、合并流：把多个输入流合并为一个流，也叫顺序流，因为在读取的时候是先读第一个，读完了在读下面一个流。

//定义字节输入合并流

SequenceInputStream seinput = new SequenceInputStream(

new FileInputStream("io/a.txt"), new FileInputStream("io/b.txt"));

byte[] buffer = new byte[10];

int len = -1;

while((len=seinput.read(buffer))!=-1){

System.out.println(new String(buffer,0,len));

}

seinput.close();

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。