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