IO流学习总结

你的名字 2023-02-21 06:36 48阅读 0赞

**01.****第一章：缓冲流****\_****概述**

**1).****什么是****“****缓冲流****”****：之前使用字节流的两个基本流：****FileOutputStream****和****FileInputStream****，以及字符流的两个流：**

**   FileWriter****和****FileReader****，在使用它们时，一次读、写一个字节数组****/****字符数组的形式非常快。我们用的字节数组****/****字符数组**

**   ****就相当于一个****“****缓存区****”****。**

**2).****由于这种方式非常快，所以****Java****类库中也提供了一种****“****缓冲流****”--****这些缓冲流内部自带一个****“****缓存区****--byte/char****数组****”****，**

**   ****用这些流可以提高我们的读、写效率。**

**3).****这些缓冲流基本上没有增加任何的方法，仍然是使用我们学过的方法，只是它们内部的工作方式不一样。**

**02.****第一章：缓冲流****\_****字节缓冲流【两个】**

**字节流：**

**A).****输出流：****OutputStream**

**|--FileOutputStream(****子类****)**

**|--FilterOutputStream(****不学****)**

**|--BufferedOutputStream(****字节缓冲流****)**  
**B).****输入流：****InputStream**

**|--FileInputStream(****子类****)**

**|--FilterInputStream(****不学****)**

**|--BufferedInputStream(****字节缓冲流****)**

**注：这两个缓冲流没有增加任何方法，仍然使用父类的方法，只是内部的工作方式不同。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70][]

**03.****第一章：缓冲流****\_****字符缓冲流【两个】**

**字符流：**

**A).****输出流：****Writer**

**|--OutputStreamWriter(****转换流****--****今天讲****)**

**|--FileWriter(****子类****--****基本流****)**

**|--BufferedWriter(****缓冲流****)**

**新增特有方法：****newLine():****输出一个换行符****(\\r\\n)**

**B).****输入流：****Reader**

**|--InputStreamReader(****转换流****--****今天讲****)**

**|--FileReader(****子类****--****基本流****)**

**|--BufferedReader(****缓冲流****)**

**新增特有方法：****readLine():****读取一行。【不读取换行符】**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        **try** (BufferedReader bufIn = **new** BufferedReader(**new** FileReader(**"demo02.txt"**));  
             BufferedWriter bufOut = **new** BufferedWriter(**new** FileWriter(**"demo02\_copy\_2.txt"**))  
        ) \{   
            *//1.**一次读写一个字符*  
*            **/\*int c = 0;*  
*            while ((c = bufIn.read()) != -1) \{* *//**从缓存区读*  
*                bufOut.write(c);**//**写入缓存区*  
*            \}\*/*  
  
*            //2.**一次读写一个字符数组*  
*            **/\*char\[\] chArray = new char\[512\];*  
*            int len = 0;*  
*            while ((len = bufIn.read(chArray)) != -1) \{* *//**从缓存区读*  
*                bufOut.write(chArray,0,len);**//**写入缓存区*  
*            \}\*/*  
  
*            //3.**一次读写一行*  
*            *String row = **null**;  
            **while**((row = bufIn.readLine()) != **null**)\{ *//**从缓存区读*  
                bufOut.write(row);*//**写入缓存区*  
                bufOut.newLine();  
            \}  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \}  
    \}  
\}

**04.****第一章：缓冲流****\_****练习****\_****文本排序****\_****案例分析**

**1).****读取****“****出师表****\_****源****.txt”--****按行读****--BufferedReader://****3.****侍中、侍郎郭攸之****.....**

**2).****解析读取的行，解析为两部分：第一部分：****3****，第二部分：内容：侍中、侍郎郭攸之****.....**

**3).for(int i = 1 ; i <= 9 ; i++)\{**

**String str = map.get(i);//****用****i****作键，取内容**

**out.write(i + "." + str);//1.xxxx**  
**   \}**

**05.****第一章：缓冲流****\_****练习****\_****文本排序****\_****案例实现**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        **try** (BufferedReader bufIn = **new** BufferedReader(**new** FileReader(**"****出师表****\_****源****.txt"**));  
             BufferedWriter bufOut = **new** BufferedWriter(**new** FileWriter(**"****出师表****\_****复制****.txt"**))  
        ) \{   
  
            *//**定义一个**Map*  
*            *Map<Integer, String> map = **new** HashMap<>();  
            *//**一次读取一行*  
*            *String row = **null**;  
            **while** ((row = bufIn.readLine()) != **null**) \{ *//row = 3.**侍中、侍郎郭攸之**.....*  
*                //**解析**row*  
*                *Integer id = Integer.*valueOf*(row.substring(0, 1));*//id = 3*  
*                *String str = row.substring(1);*//str = ".**侍中、侍郎郭攸之**.....";*  
*                //**存储到**Map**中*  
*                *map.put(id, str);  
            \}  
            *//**写个**for**循环*  
*            ***for** (**int** i = 1; i <= 9 ; i++) \{   
                *//**用**i**做键，到**map**中取值*  
*                *String str = map.get(i);  
                *//**输出到文件*  
*                *bufOut.write(i + str);  
                bufOut.newLine();  
            \}  
            System.***out***.println(**"****复制完毕！****"**);  
  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \}  
    \}  
\}

**-------------------------------------------------------------**

**06.****第二章：转换流****\_****编码引出的问题**

**1).****当磁盘上有一个****“GBK”****编码的文件时，如果我们用****IDEA****读取，由于****IDEA****默认编码方式为：****UTF-8****，**

**    ****所以会导致读取到程序中的数据：乱码。**

**2).FileReader****和****FileWriter****只能根据当前运行时环境****(IDEA)****的编码方式，不能灵活的更改为其它方式。**

**3).****我们可以使用它们的父类：**

**1).****字符输出流：****Writer**

**   |--OutputStreamWriter(****转换流****)--****可以指定编码表**

**API****：从字符流到字节流的桥梁**

**     ****程序中：****"****你好****"-->** **编码表**** -->** **字节**** -->** **字节流**** -->** **文件**

**|--FileWriter(****基本流****)--****只能使用默认编码表**

**2).****字符输入流：**

**   ****|--InputStreamReader(****转换流****)--****可以指定编码表**

**API****：从字节流到字符流的桥梁**

**程序中：****"****你好****"<--** **编码表**** <--** **字节**** <--****字节流**** <--** **文件**

**|--FileReader(****基本流****)--****只能使用默认编码表**

**4).****这两个转换流就可以****“****指定某种编码方式****”****来读、写文件。**

**07.****第二章：转换流****\_****转换输出流****OutputStreamWriter****的使用**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        **try** (OutputStreamWriter osw = **new** OutputStreamWriter(  
                            **new** FileOutputStream(**"demo05\_GBK.txt"**),**"GBK"**)) \{   
            osw.write(**"****你好****"**);  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \}  
    \}  
\}

**08.****第二章：转换流****\_****转换输入流****InputStreamReader****的使用**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        **try** (InputStreamReader isr = **new** InputStreamReader(  
                                **new** FileInputStream(**"demo05\_GBK.txt"**),**"GBK"**)) \{   
            **int** c = 0;  
            **while** ((c = isr.read()) != -1) \{   
                System.***out***.println((**char**)c);  
            \}  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \}  
    \}  
\}

**乱码的产生：文件中的编码和程序编码不一致；**

**解决乱码问题：将编码变为一致。**

**09.****第二章：转换流****\_****练习****\_****转换文件编码**

**1).****复制一个****GBK****编码的文件，复制为****UTF-8****编码的。**

**2).****示例代码：**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        *//1.**用**GBK**读取*  
*        ***try** (InputStreamReader in = **new** InputStreamReader(  
                                **new** FileInputStream(**"demo06\_GBK.txt"**),**"GBK"**);  
             *//2.**用**UTF-8**输出*  
*             *OutputStreamWriter out = **new** OutputStreamWriter(  
                                **new** FileOutputStream(**"demo06\_utf8.txt"**),**"UTF-8"**)  
            ) \{   
            **int** c = 0;  
            **while** ((c = in.read()) != -1) \{   
                out.write(c);  
            \}  
            System.***out***.println(**"****转换完毕！****"**);  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \}  
  
    \}  
\}

**------------------------------------------------------------**

**10.****第三章：序列化****\_****概述：**

**1).****什么是****“****序列化****”****：将内存中的****“****对象****(****包括：包名，类名****)”****连同****“****属性名，值****”****一起存储到一个文件中，这个过程叫：序列化。**

**2).****什么是****“****反序列化****”****：将之前序列化的对象，再次的读取到内存中，并创建对象，为属性赋值，这个过程叫：反序列化。**

**11.****第三章：序列化****\_****序列化流****ObjectOutputStream****类**

**1).****注意：被序列化的类，必须实现：****java.io.Serializable****接口**

**2).****示例代码：**

**public class** Student **implements** Serializable \{   
    String **name**;  
    **int** **age**;  
  
    **public** Student(String name, **int** age) \{   
        **this**.**name** = name;  
        **this**.**age** = age;  
    \}  
  
    @Override  
    **public** String toString() \{   
        **return** **"Student\{"** \+  
                **"name='"** \+ **name** \+ **'****\\'****'** \+  
                **", age="** \+ **age** \+  
                **'\}'**;  
    \}  
\}

**测试类：**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        Student stu = **new** Student(**"****成龙****"**, 17);  
  
        *//**序列化对象*  
*        ***try** (ObjectOutputStream oos = **new** ObjectOutputStream(

**new** FileOutputStream(**"demo08\_obj.txt"**))) \{   
  
            oos.writeObject(stu);  
  
            System.***out***.println(**"****完毕！****"**);  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \}  
  
    \}  
\}

**12.****第三章：序列化****\_****反序列化****ObjectInputStream****类**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        **try** (ObjectInputStream ois = **new** ObjectInputStream(

**new** FileInputStream(**"demo08\_obj.txt"**))) \{   
  
            Object o = ois.readObject();*//1.**从文件中读取**”**包名**" + "**类名**";2.**到项目中找到那个包下的那个类**;3.**将这个类创建对象；**4.**参考类中的属性到文件中找对应的值，找到，就为成员属性赋值；*  
*            *Student stu = (Student)o;  
            System.***out***.println(stu);  
  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \} **catch** (ClassNotFoundException e) \{   
            e.printStackTrace();  
        \}  
    \}  
\}

**13.****第三章：序列化****\_****关于版本号**

**1).****任何一个被序列化的类，编译器都会隐式的添加一个变量：**

**   ****private static final long** ***serialVersionUID*** = \-6642906621147195767L;

2).序列化

3).修改Student类：

....

String address;//增加属性

4).编译器会自动的修改这个序列号：

**private static final long** ***serialVersionUID*** = 8842906621147195767L;

5).反序列化：

1).比较两个序列号，发现不一致；抛出异常

\----------------------------------------------------------------------------------------

建议：由程序员来维护这个序列号：

**public class** Student **implements** Serializable \{   
     //自定义的序列号  
    **private static final long** ***serialVersionUID*** = 1L;  
  
    **int** **stuAge**;  
    String **address**;  
  
    **public** Student(**int** stuAge, String address) \{   
        **this**.**stuAge** = stuAge;  
        **this**.**address** = address;  
    \}  
  
    @Override  
    **public** String toString() \{   
        **return** **"Student\{"** \+  
                **"stuAge="** \+ **stuAge** \+  
                **", address='"** \+ **address** \+ **'****\\'****'** \+  
                **'\}'**;  
    \}  
\}

**14.****第三章：序列化****\_****禁止属性被序列化****transient****关键字**

**1).****如果某个属性不想被序列化，可以将这个成员属性修饰为：****transient**

**public class** Student **implements** Serializable \{   
     String **name**;  
     **transient int** **age**;

**15.****第三章：序列化****\_****练习****\_****序列化集合**

**1).****不要在一个文件中同时序列化多个对象，如果要存储多个对象，可以将这个多个对象存储到一个集合中，**

**   ****然后将这个集合序列化到文件中。**

**ArrayList<Student> list = new ArrayList<>();**

**   ****要求****：**

**1).ArrayList****必须实现****Serializable****接口****;**

**2).Student****必须实现****Serializable****接口****;**

**3).Student****中的****“****引用类型的属性****”****必须实现****Serializable****接口****;**

**这样才可以成功的序列化一个****ArrayList****对象。**

**2).****示例代码：**

**1).Student****类：**

**public class** Student **implements** Serializable\{   
    **private static final long** ***serialVersionUID*** = 1;  
    **private** String **name**;  
    **private int** **age**;  
    **public** Student() \{   
    \}  
    **public** Student(String name, **int** age) \{   
        **this**.**name** = name;  
        **this**.**age** = age;  
    \}  
    **public** String getName() \{   
        **return** **name**;  
    \}  
    **public void** setName(String name) \{   
        **this**.**name** = name;  
    \}  
    **public int** getAge() \{   
        **return** **age**;  
    \}  
    @Override  
    **public** String toString() \{   
        **return** **"Student\{"** \+  
                **"name='"** \+ **name** \+ **'****\\'****'** \+  
                **", age="** \+ **age** \+  
                **'\}'**;  
    \}  
    **public void** setAge(**int** age) \{   
        **this**.**age** = age;  
    \}  
\}

**2).****序列化测试类：**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        Student stu1 = **new** Student(**"****成龙****"**, 17);  
        Student stu2 = **new** Student(**"****洪金宝****"**, 19);  
        Student stu3 = **new** Student(**"****甄子丹****"**, 16);  
        ArrayList<Student> list = **new** ArrayList<>();  
        list.add(stu1);  
        list.add(stu2);  
        list.add(stu3);  
        **try** (ObjectOutputStream out = **new** ObjectOutputStream(  
                                        **new** FileOutputStream(**"demo10.txt"**))) \{   
            out.writeObject(list);  
            System.***out***.println(**"****序列化完毕！****"**);  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \}  
    \}  
\}

**3).****反序列化测试类：**

**public class** Demo02 \{   
    **public static void** main(String\[\] args) \{   
        **try** (ObjectInputStream in = **new** ObjectInputStream(

**new** FileInputStream(**"demo10.txt"**))) \{   
            ArrayList<Student> stuList = (ArrayList<Student>)in.readObject();  
            **for** (Student stu : stuList) \{   
                System.***out***.println(stu);  
            \}  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \} **catch** (IOException e) \{   
            e.printStackTrace();  
        \} **catch** (ClassNotFoundException e) \{   
            e.printStackTrace();  
        \}  
    \}  
\}

**-------------------------------------------------------------**

**16.****第四章：打印流****\_****概述**

**1).Java****提供了两个打印流：**

**1).****字节打印流：****PrintStream**

**2).****字符打印流：****PrintWriter**

**2).****特点：**

**1).****只有输出流，没有输入流；**

**2).****可以向文件输出，也可以向控制台输出；**

**17.****第四章：打印流****\_****字节打印流****PrintStream****类**

**public class** Demo \{   
    **public static void** main(String\[\] args) \{   
        PrintStream out = System.***out***;  
        out.println(**"HelloWorld!"**);  
  
        *//**可以更改**System.out**对象为其它**PrintWriter**，使其向文件输出*  
*        ***try** (PrintStream ps = **new** PrintStream(**"demo11.txt"**)) \{   
  
            *//**将这个流赋值给**System.out*  
*            *System.*setOut*(ps);  
  
            *//**测试*  
*            *System.***out***.println(**"****呵呵，输出到文件了！****"**);  
  
            *//**还原*  
*            *System.*setOut*(out);  
            System.***out***.println(**"****呵呵，我又回来了！****"**);  
        \} **catch** (FileNotFoundException e) \{   
            e.printStackTrace();  
        \}  
    \}  
\}

**=============================================================**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200629135550251.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0,size_16,color_FFFFFF,t_70