Week04_day03 IO流（下） 字符流、缓冲流、转换流

字符流

Reader

方法：

1，int read()：

读取一个字符。返回的是读到的那个字符。如果读到流的末尾，返回-1.

2，int read(char[])：

将读到的字符存入指定的数组中，返回的是读到的字符个数，也就是往数组里装的元素的个数。如果读到流的末尾，返回-1.

3，close()

读取字符其实用的是window系统的功能，就希望使用完毕后，进行资源的释放

由于Reader也是抽象类，所以想要使用字符输入流需要使用Reader的实现类。查看API文档。找到了FileReader。

1，用于读取文本文件的流对象。

2，用于关联文本文件。

构造函数：在读取流对象初始化的时候，必须要指定一个被读取的文件。

如果该文件不存在会发生FileNotFoundException.

Writer

Writer中的常见的方法：

1，write(ch): 将一个字符写入到流中。

2，write(char[]): 将一个字符数组写入到流中。

3，write(String): 将一个字符串写入到流中。

4，flush():刷新流，将流中的数据刷新到目的地中，流还存在。

5，close():关闭资源：在关闭前会先调用flush()，刷新流中的数据去目的地。然流关闭。

发现基本方法和OutputStream 类似，有write方法，功能更多一些。可以接收字符串。

同样道理Writer是抽象类无法创建对象。查阅API文档，找到了Writer的子类FileWriter

Demo

package com.serendipity.reader;import java.io.File;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.Reader;import java.io.Writer;/** * 字符流：只能来读取文本      * 字符输入流的抽象类Reader   实现类：FileReader *  * read() * close() * 字符输出流的抽象类Writer   实现类：FileWriter * write() * flush() * close() *  *  * @author Serendipity * */public class Demo1 {public static void main(String[] args) throws IOException  {test4();}/** * 字符流读写 * @throws IOException */private static void test4() throws IOException {File f=new File("src/abc.txt");Writer w=new FileWriter(f,true);String data="\r\n不要998只要98";//w.write(data);w.write(data.toCharArray());w.flush();w.close();}private static void test3() {//1.创建文件File f=new File("src/abc.txt");//2.创建reader对象Reader r=null;try {r = new FileReader(f);//3.读写char[] cuf=new char[1024];int length=0;while((length=r.read(cuf))!=-1){System.out.println(new String(cuf,0,length));//String.valueOf(cuf, 0, length);}} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}finally {//System.out.println((char)data);//4.释放资源try {if(r!=null){r.close();}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}private static void test2() throws FileNotFoundException, IOException {//1.创建文件File f=new File("src/abc.txt");//2.创建reader对象Reader r=new FileReader(f);//3.读写char[] cuf=new char[1024];int length=0;while((length=r.read(cuf))!=-1){System.out.println(new String(cuf,0,length));//String.valueOf(cuf, 0, length);}//System.out.println((char)data);//4.释放资源r.close();}private static void test1() throws FileNotFoundException, IOException {//1.创建文件File f=new File("src/abc.txt");//2.创建reader对象Reader r=new FileReader(f);//3.读写int data = r.read();System.out.println((char)data);//4.释放资源r.close();}}

缓冲流

字节缓冲流和字符缓冲流：可以提高效率。用字节流去读写操作，可以一个字节的去读写，这种效率非常低。用个缓冲字节数组去读写操作，可以很大程度上去提高读写的效率，而且数组的长度越大，效率会越高，一般是1024或者是1024的整数倍；sun公司也知道缓冲数组可以提高读写效率，所以给我们设计了缓冲流，用来提高读写效率；底层维护了一个长度是8192长度数组。

缓冲流不能真正的去进行读写操作，真正去进行读写的操作的，还是我们的FileReader FileWriter   FileInputStream  FileOutputStream.

 

字符缓冲流:BufferedReader      BufferedWriter

字节缓冲流:BufferedInputStream    BufferedOutputStream

Demo

package com.serendipity.buffer;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;/** * 字节流和字符流： 1.读写一个字节 ===》缓冲数组=====》为了提高效率 2.读写一个字符 ===》缓冲数组=====》为了提高效率 *  * 缓冲流： *  * 缓冲流不能够真正的去进行读写操作，真正去读写操作的还是字节流和字符流，缓冲流只是对字节流和字符流做了一个装饰，把功能增强， * 然后达到提高读写效率的目的。（转换流也不能真正的去读写。） 设计模式： 1.单例模式 2.工厂模式 3.装饰着模式 *  *  * 底层就是维护了一个数组 数组的长度是8192 写的时候 先读进缓冲数组里面，当你刷新的时候或者数组满的时候，采取真正的写。 *  * 1.字节缓冲流 BufferedInputStream 缓冲字节输入流 *  * int read() 参见 InputStream 的 read 方法的常规协定。 int read(byte[] b, int off, int * len) 从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。 *  * BufferedOutputStream缓冲字节输出流 *  * 2.字符缓冲流 BufferedReader 缓冲字符输入流 readLine();如果已到达流末尾，则返回 null BufferedWriter * 缓冲字符输出流 void newLine() 写入一个行分隔符。 *  *  *  * @author Serendipity * */public class Demo1 {public static void main(String[] args) {}/** * 字符缓冲流复制文本 */private static void testBufferRW() {/** * 缓冲字符流  赋值文本 */File f=new File("11.txt");File f1=new File("1.txt");BufferedReader br=null;BufferedWriter bw=null;try {br=new BufferedReader(new FileReader(f));bw=new BufferedWriter(new FileWriter(f1));String data=null;while((data=br.readLine())!=null){//写字符数组   写字符串bw.write(data);bw.newLine();//写入分行符}} catch (Exception e) {// TODO: handle exceptione.printStackTrace();}finally {if(bw!=null){try {bw.flush();bw.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if(br!=null){try {br.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}private static void testBufferReadLine() throws FileNotFoundException, IOException {/*//1.转换流   2.BufferedInputStreamBufferedInputStream bis=new BufferedInputStream(System.in);int read = bis.read();System.out.println((char)read);*/BufferedReader br=new BufferedReader(new FileReader(new File("11.txt")));//如果已到达流末尾，则返回 null /*System.out.println(br.readLine());System.out.println(br.readLine());*/String data=null;while((data=br.readLine())!=null){System.out.println(data);}}private static void testBuffReader() throws FileNotFoundException, IOException {File file = new File("11.txt");FileReader in = new FileReader(file);BufferedReader br=new BufferedReader(in);char[] cbuf=new char[1024];int length=0;while((length=br.read(cbuf))!=-1){System.out.println(new String(cbuf,0,length));}//只需要把  br关   自动关inbr.close();}/** * 字节转换输入输出流 * @throws FileNotFoundException * @throws IOException */private static void run1() throws FileNotFoundException, IOException {/** * 当读取数据量比较大的时候  可以用缓冲流 *  *  */BufferedInputStream bis=new BufferedInputStream(new FileInputStream("1.txt"));BufferedOutputStream  bos=new BufferedOutputStream(new FileOutputStream("11.txt"));byte[] buf=new byte[1024];int length=0;while((length=bis.read(buf))!=-1){System.out.println(new String(buf,0,length));//写入bos.write(buf,0,length);bos.flush();}//bos.close();bis.close();}}

转换流

InputStreamReader：字节到字符的桥梁。

OutputStreamWriter：字符到字节的桥梁。

 

它们有转换作用，而本身又是字符流。所以在构造的时候，需要传入字节流对象进来。

构造函数：

InputStreamReader(InputStream)

通过该构造函数初始化，使用的是本系统默认的编码表GBK。

InputStreamReader(InputStream,StringcharSet)

通过该构造函数初始化，可以指定编码表。

OutputStreamWriter(OutputStream)

通过该构造函数初始化，使用的是本系统默认的编码表GBK。

OutputStreamWriter(OutputStream,StringcharSet)

通过该构造函数初始化，可以指定编码表。

注意：

操作文件的字符流对象是转换流的子类。

Reader

|--InputStreamReader

|--FileReader

Writer

|--OutputStreamWriter

|--FileWriter

 

注意：

在使用FileReader操作文本数据时，该对象使用的是默认的编码表。

如果要使用指定编码表时，必须使用转换流。

 

InputStreamReader

查看API文档，发现是字节流通向字符流的桥梁。查看构造，可以传递字节流，可以指定编码，该流可以实现什么功能？很显然可以包装我们的字节流，自动的完成节流编码和解码的工作。该流是一个Reader的子类，是字符流的体系。所以将转换流称之为字节流和字符流之间的桥梁。

Demo

package com.serendipity.inputstreamreader;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import java.io.Reader;import java.io.UnsupportedEncodingException;import java.io.Writer;/** *   * 转换流： * 1.InputStreamReader  继承Reader    是字节流通向字符流的桥梁 * 构造方法摘要 InputStreamReader(InputStream in)           创建一个使用默认字符集的 InputStreamReader。 InputStreamReader(InputStream in, String charsetName)   指定字符集去读取          创建使用指定字符集的 InputStreamReader。                    int read()           读取单个字符。  int read(char[] cbuf, int offset, int length)           将字符读入数组中的某一部分。           void close()           关闭该流并释放与之关联的所有资源。  *  * 2.OutputStreamWriter   OutputStreamWriter 是字符流通向字节流的桥梁 * OutputStreamWriter(OutputStream out)           创建使用默认字符编码的 OutputStreamWriter。                    OutputStreamWriter(OutputStream out, String charsetName)           创建使用指定字符集的 OutputStreamWriter。                         void close()           关闭此流，但要先刷新它。  void flush()           刷新该流的缓冲。  String getEncoding()           返回此流使用的字符编码的名称。  void write(char[] cbuf, int off, int len)           写入字符数组的某一部分。  void write(int c)           写入单个字符。  void write(String str, int off, int len)           写入字符串的某一部分。  *  *  * @author Serendipity * */public class Demo1 {public static void main(String[] args) throws IOException {//Reader r=new reader(Sytem.in);/*InputStream is=new FileInputStream(System.in);*/InputStreamReader isr=new InputStreamReader(System.in);char[] cbuf=new char[1024];int read = isr.read(cbuf);//阻塞型方法System.out.println(String.valueOf(cbuf,0,read));}private static void run3() throws FileNotFoundException, UnsupportedEncodingException, IOException {//从右往左看    字节流转字符流    字节输出流转 字符输出流//OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("src/abc1.txt"), "utf-8");//从左往右看  是字符流通向字节流的桥梁   字符输出流转字节输出流     推荐File file = new File("src/abc1.txt");FileOutputStream out = new FileOutputStream(file,true);OutputStreamWriter osw1=new OutputStreamWriter(out, "utf-8");String  data="hello哦哦哦";osw1.write(data);osw1.flush();osw1.close();}private static void run1() throws UnsupportedEncodingException, FileNotFoundException, IOException {//用转换流去读取文本     InputStreamReader:把字节流变成了字符流/*InputStreamReader  isr=new InputStreamReader(new FileInputStream(new File("src/abc.txt")));Reader  isr1=new InputStreamReader(new FileInputStream(new File("src/abc.txt")));char[] cbuf=new char[1024];int read = isr.read(cbuf);System.out.println(String.valueOf(cbuf, 0, read));*//*Reader r=new FileReader("src/abc.txt");char[] cbuf=new char[1024];int length = r.read(cbuf);System.out.println(String.valueOf(cbuf, 0, length));*/Reader  isr1=new InputStreamReader(new FileInputStream(new File("src/abc.txt")),"utf-8");char[] cbuf=new char[1024];int read = isr1.read(cbuf);System.out.println(String.valueOf(cbuf, 0, read));}}