IO流学习总结

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

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

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

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

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

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

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

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

字节流：

A).输出流：OutputStream

|--FileOutputStream(子类)

|--FilterOutputStream(不学)

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

|--FileInputStream(子类)

|--FilterInputStream(不学)

|--BufferedInputStream(字节缓冲流)

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

 

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();
        }
    }
}

=============================================================