Java学习（缓冲流,转换流,序列化和反序列化,transient关键字,InvalidClassException异常,打印流）

2022/2/8 2/11
一：缓冲流

1.缓冲流
        使用基本的字节输入流读取文件：一次读取一个返回一个
        使用字节缓冲输入流：给基本的字节输入流增加一个缓冲区（数组）提高基本的字节输入流
        的读取效率

2.BufferedOutputStream字节缓冲输出流

package ln.javatest.day15.demo01;


import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.FileOutputStream;

public class Demo01BufferedOutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建FileOutputStream对象，构造方法中绑定要输出的目的地
        FileOutputStream fos = new FileOutputStream("D:\桌面\Java笔记\1.txt");
        //2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //3.使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中
        //缓冲区中放的必须是数组
        //getBytes()是将字符串转换为字节数组
        bos.write("把数据写入到内部缓冲区中".getBytes());
        //4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区中的数据，刷新到文件中
        bos.flush();
        //5.释放资源（会先调用flush方法刷新数据，第四步可以省略）
        bos.close();
    }

}

3.BufferedInputStream字节缓冲输入流

package ln.javatest.day15.demo01;


import java.io.*;

public class Demo01BufferedOutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("D:\桌面\Java笔记\2.txt");
        //2.创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的读取效率
        BufferedInputStream bis = new BufferedInputStream(fis);
        //3.使用BufferedInputStream对象中的方法read，读取文件
        //int read() 从输入流中读取数据的下一个字节


        //int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
        byte[] bytes = new byte[1024];
        int len = 0;
        while((len = bis.read(bytes))!= -1){
            //将数组转换为自己穿
            System.out.println(new String(bytes,0,len));
        }

        //4.释放资源
        bis.close();

    }

}

4.复制文件

package ln.javatest.day15.demo01;


import java.io.*;

public class Demo01CopyFile {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        //1.创建字节缓冲输入流对象，构造方法中传递字节输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\桌面\Java笔记\2.txt"));
        //2.创建字节缓冲输出流对象，构造方法中传递字节输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\桌面\Java笔记\1.txt"));
        //3.使用字节缓冲输入流对象中的方法read，读取文件
        //一次读取一个字节写入一个字节的方式 // //复制文件共耗时：4毫秒
        

        //使用数组缓冲读取多个字节，写入多个字节 //复制文件共耗时：10毫秒
        int len = 0;
        byte[] bytes = new byte[1024];
        while((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        // 5.释放资源（会先把缓冲区中的数据，刷新到文件中
        long e = System.currentTimeMillis();
        System.out.println("复制文件共耗时："+(e-s)+"毫秒");

    }
}

5.BufferedWriter字符缓冲输出流

package ln.javatest.day15.demo01;


import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Demo01BufferedWriter {
    public static void main(String[] args) throws IOException {
        // 1.创建字符缓冲输出流对象，构造方法中传递字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\桌面\Java笔记\1.txt"));
        // 2.调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区中
        for (int i = 0; i < 3; i++) {
            bw.write("王嘉尔"+i);
            //bw.write("rn");
            bw.newline();
        }
        // 3.调用字符缓冲输出流中的方法flush，把内存缓冲区的数据，刷新到文件中
        bw.flush();
        // 4.释放资源
        bw.close();
    }
}

6.BufferedReader字符缓冲输入流

package ln.javatest.day15.demo01;


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Demo02BufferedReader {
    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输入流对象，构造方法中传递字符输入流
        BufferedReader br = new BufferedReader(new FileReader("D:\桌面\Java笔记\1.txt"));
        //2.使用字符缓冲输入流对象中的方法read/readLine读取文本
        
        
        String line;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }
        //3.释放资源
        br.close();
    }
}

7.练习

package ln.javatest.day15.demo01;


import java.io.*;
import java.util.HashMap;

public class Demo01test {
    public static void main(String[] args) throws IOException {
        //1.创建一个HashMap集合对象：
        //        k:存储每行文本的序号（1,2,3）
        //        value:存储每行的文本
        HashMap map = new HashMap<>();
        // 2.创建字符缓冲输入流对象，构造方法中绑定字符输入流
        BufferedReader br = new BufferedReader(new FileReader("D:\桌面\Java笔记\2.txt"));
        // 3.创建字符缓冲输出流对象，构造方法中绑定字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\桌面\Java笔记\1.txt"));
        // 4.使用自付缓冲输入流中的方法readLine，逐行读取文本
        String line;
        while((line = br.readLine())!=null){
            // 5.对读取到的文本进行切割，获取行中的序号和文本内容
            //根据.来进行切割
            String[] arr = line.split("\.");
            // 6.把切割好的序号和文本的内容存储到HashMap集合中（key序号是有序的，会自动排序123）
            map.put(arr[0],arr[1]);
        }
        // 7.遍历HashMap集合，获取每一个键值对
        for(String key : map.keySet()){
            String value = map.get(key);
            // 8.把每一个键值对，拼接为一个文本行
                line = key + "." + value;
            // 9.把拼接好的文本，使用字符缓冲输出流中的方法write，写入到文件中
                bw.write(line);
                bw.newline();//写换行
        }
        // 10.释放资源
        bw.close();
        br.close();
    }
}

二.转换流

1.字符编码和字符集
字符编码：就是一套自然语言的字符与二进制数之间的对应规则。
编码表：生活中文字和计算机中二进制的对应规则
字符集：也叫编码表，是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
注意：计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见的字符集有ASCII字符集、GBK字符集、Unicode字符集等。

2.编码引出的问题：
FileReader可以读取IDE默认编码格式（UTF-8）的文件
FileReader读取系统默认编码（中文GBK）会产生乱码

3.OutputStreamWriter转换流

package ln.javatest.day15.demo01;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    
    public static void main(String[] args) throws IOException {
        //1.创建OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称
        FileOutputStream fos = new FileOutputStream("D:\桌面\Java笔记\GBK.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
        //2.使用OutputStreamWriter对象中的方法writer，把字符转换为字节存储在缓冲区中（编码）
        osw.write("你好");
        //3.使用OutputStreamWriter对象中的方法flush，把内存缓冲区中的字节刷新到文件中（使用字节流写字节的过程）
        osw.flush();
        //4.释放资源
        osw.close();
    }
}

4.InputStreamReader转换流

package ln.javatest.day15.demo01;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        read_utf_8();
    }
    
    private static void read_utf_8() throws IOException {
        //1.创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
        FileInputStream fis = new FileInputStream("D:\桌面\Java笔记\1.txt");
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);
        }
        //3.释放资源
        isr.close();
    }
}

三.序列化和反序列化
1）序列化：把对象以流的方式，写入到文件中保存，叫写对象，也叫对象的序列化。
对象中包含的不仅仅是字符，还包含字节，所以使用字节流
ObjectOutputStream：对象的序列化流。

package ln.javatest.day15.demo01;


import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //1.创建ObjectOutputStream对象，构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\桌面\Java笔记\1.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject，把对象写入到文件中
        oos.writeObject(new Person("王嘉尔",20));
        //3.释放资源
        oos.close();
    }
}

package ln.javatest.day15.demo01;


import java.io.Serializable;

public class Person implements Serializable {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

2）反序列化：把文件中保存的对象，以流的方式读取出来，叫做读对象，也叫对象的反序列化
读取的文件保存的都是字节，使用字节流
ObjectInputStream:对象的反序列化流

package ln.javatest.day15.demo01;


import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStreamDemo01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建ObjectInputStream对象，构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\桌面\Java笔记\1.txt"));
        //2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
        Object o= ois.readObject();
        //3.释放资源
        ois.close();
        //4.使用读取出来的对象（打印）
        System.out.println(o);
        Person p = (Person) o;
        System.out.println(p.getName()+p.getAge());
    }
}

3）瞬态关键字transient：
        被transient修饰的成员变量，不能被序列化。
注意：static关键字（静态关键字），它是优先于非静态加载到内存中（静态优先于对象进入到内             存中），所以被static修饰的成员变量不能被序列化，序列化的都是对象。

4)InvalidClassException异常

package ln.javatest.day15.demo01;

import java.io.Serializable;

public class Person implements Serializable {
    //解决方案
    private static final long serialVersionUID = 1L;
    private String name;
    //这里如果修改了类的定义，那么就会给Person.class文件重新编译生成一个新的序列号
    //这里直接运行反序列化，序列号不一样，则抛出异常
    //private int age;
    public int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

5）序列化集合

package ln.javatest.day15.demo01;


import java.io.*;
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //    1.定义一个存储Person对象的ArrayList集合
        ArrayList list = new ArrayList<>();
        //    2.往ArrayList集合中存储Person对象
        list.add(new Person("王嘉尔",18));
        list.add(new Person("易烊千玺",20));
        list.add(new Person("熊丰",32));
        //    3.创建一个序列化流ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\桌面\Java笔记\1.txt"));
        //    4.使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
        oos.writeObject(list);
        //    5.创建一个反序列化ObjectInputStream对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\桌面\Java笔记\1.txt"));
        //    6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
        Object o = ois.readObject();
        //    7.把Object类型的集合转换为ArrayList类型
        ArrayList p = (ArrayList) o;
        //    8.遍历ArrayList集合
        for (Person p1 : p) {
            System.out.println(p1);
        }
        //    9.释放资源
        oos.close();
        ois.close();
    }
}

6）打印流

package ln.javatest.day15.demo01;


import java.io.FileNotFoundException;
import java.io.PrintStream;

public class PrintStreamDemo01 {
    public static void main(String[] args) throws FileNotFoundException {
        //创建打印流PrintStream对象，构造方法中绑定要输出的目的地
        PrintStream ps = new PrintStream("D:\桌面\Java笔记\1.txt");
        // 如果使用继承自父类的write方法写数据，那么查看数据的时候会查询编码表 97->a
        ps.write(97);  //a
        ps.println(97);   //97
        //释放资源
        ps.close();
    }
}

package ln.javatest.day15.demo01;


import java.io.FileNotFoundException;
import java.io.PrintStream;

public class PrintStreamDemo02 {
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("我在控制台输出");
        PrintStream ps = new PrintStream("D:\桌面\Java笔记\1.txt");
        System.setOut(ps);
        System.out.println("我在打印流的目的地中输出");
        ps.close();
    }
}