【JAVASE学习笔记之缓冲流·转换流·序列化·打印流】:IO系列(三)

标签: IO  javase  java

第一章 缓冲流

1.1 概述

缓冲流是对4个基本的 FileXxx 流的增强,所以也是4个流,按照数据类型分类:

字节缓冲流: BufferedInputStream , BufferedOutputStream
字符缓冲流: BufferedReader , BufferedWriter

缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO
次数,从而提高读写的效率

1.2 字节缓冲流

构造方法

public BufferedInputStream(InputStream in) :创建一个 新的缓冲输入流。
public BufferedOutputStream(OutputStream out) : 创建一个新的缓冲输出流。

构造方法示例代码如下:

// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"))

效率测试

查询API,缓冲流读写方法与基本的流是一致的,我们通过复制大文件(375MB),测试它的效率

1. 基本流,代码如下:

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
        long start = System.currentTimeMillis();
// 创建流对象
        try (
                FileInputStream fis = new FileInputStream("jdk9.exe");
                FileOutputStream fos = new FileOutputStream("copy.exe")
        ) {
// 读写数据
            int b;
            while ((b = fis.read()) != ‐1) {
                fos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("普通流复制时间:"+(end ‐ start)+" 毫秒");
    }
}

十几分钟过去了..

2. 缓冲流,代码如下:

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
        long start = System.currentTimeMillis();
// 创建流对象
        try (
                BufferedInputStream bis =
                        new BufferedInputStream(new FileInputStream("jdk9.exe"));
                BufferedOutputStream bos =
                        new BufferedOutputStream(new FileOutputStream("copy.exe"))
            ) {
// 读写数据
        int b;
        while ((b = bis.read()) != ‐1) {
        bos.write(b);
        }
        } catch (IOException e) {
        e.printStackTrace();
        }
// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流复制时间:"+(end ‐ start)+" 毫秒");
        }
        }

缓冲流复制时间:8016 毫秒

如何更快呢?
使用数组的方式,代码如下:

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
        long start = System.currentTimeMillis();
// 创建流对象
        try (
                BufferedInputStream bis =
                        new BufferedInputStream(new FileInputStream("jdk9.exe"));
                BufferedOutputStream bos =
                        new BufferedOutputStream(new FileOutputStream("copy.exe"))
        ) {
// 读写数据
            int len;
            byte[] bytes = new byte[8*1024];
            while ((len = bis.read(bytes)) != ‐1) {
                bos.write(bytes, 0 , len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流使用数组复制时间:"+(end ‐ start)+" 毫秒");
    }
}

缓冲流使用数组复制时间:666 毫秒

1.3 字符缓冲流

构造方法

public BufferedReader(Reader in) :创建一个 新的缓冲输入流。
public BufferedWriter(Writer out) : 创建一个新的缓冲输出流

构造方法示例代码如下:

// 创建字节缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字节缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致,不再阐述,我们来看它们具备的特有方法

BufferedReader: public String readLine() : 读一行文字。
BufferedWriter: public void newLine() : 输出一个换行符,由系统属性定义符号

readLine 方法演示,代码如下:

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
// 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字
        String line = null;
// 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("‐‐‐‐‐‐");
        }
// 释放资源
        br.close();
    }
}

newLine 方法演示,代码如下:

public class BufferedWriterDemo throws IOException {
        public static void main(String[] args) throws IOException {
// 创建流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 写出数据
        bw.write("Vi");
// 写出换行
        bw.newLine();
        bw.write("ew");
        bw.newLine();
        bw.write("D");
        bw.newLine();
// 释放资源
        bw.close();
        }
}
输出效果:
        Vi
        ew
        D

第二章 转换流

2.1 字符编码和编码表

字符编码
计算机中储存的信息都是用二进制数表示的,而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制
数转换之后的结果。
按照某种规则,将字符存储到计算机中,称为编码 。
将存储在计算机中的二进制数按照某种规则解析显示出来,称为解码 。
比如说,按照A规则存储,同样按照A规则解析,那么就能显示正确的文本f符号。反之,按照A规则存储,再按照B
规则解析,就会导致乱码现象。
字符编码 Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

2.2 编码引出的问题

在IDEA中,使用 FileReader 读取项目中的文本文件。由于IDEA的设置,都是默认的 UTF-8 编码,所以没有任何
问题。但是,当读取Windows系统中创建的文本文件时,由于Windows系统的默认是GBK编码,就会出现乱码

public class ReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("E:\\File_GBK.txt");
        int read;
        while ((read = fileReader.read()) != ‐1) {
            System.out.print((char)read);
        }
        fileReader.close();
    }
}
输出结果:
        ���

那么如何读取GBK编码的文件呢?

转换流 java.io.InputStreamReader ,是Reader的子类,是从字节流到字符流的桥梁。它读取字节,并使用指定
的字符集(编码表)将其解码为字符。它的字符集可以由名称指定,也可以使用平台的默认字符集。

构造方法

InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。

构造举例,代码如下:

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

指定编码读取

public class ReaderDemo2 {
    public static void main(String[] args) throws IOException {
// 定义文件路径,文件为gbk编码
        String FileName = "E:\\file_gbk.txt";
// 创建流对象,默认UTF8编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
// 创建流对象,指定GBK编码
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
// 定义变量,保存字符
        int read;
// 使用默认编码字符流读取,乱码
        while ((read = isr.read()) != ‐1) {
            System.out.print((char)read); // ��Һ�
        }
        isr.close();
// 使用指定编码字符流读取,正常解析
        while ((read = isr2.read()) != ‐1) {
            System.out.print((char)read);// 大家好
          }
        isr2.close();
    }
}

2.4 OutputStreamWriter类

转换流 java.io.OutputStreamWriter ,是Writer的子类,是从字符流到字节流的桥梁。使用指定的字符集(编码
表)将字符编码为字节。它的字符集可以由名称指定,也可以使用平台的默认字符集。

构造方法

OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流

构造举例,代码如下:

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

指定编码写出:

public class OutputDemo {
    public static void main(String[] args) throws IOException {
// 定义文件路径
        String FileName = "E:\\out.txt";
// 创建流对象,默认UTF8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
// 写出数据
        osw.write("你好"); // 保存为6个字节
        osw.close();
// 定义文件路径
        String FileName2 = "E:\\out2.txt";
// 创建流对象,指定GBK编码
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
// 写出数据
        osw2.write("你好");// 保存为4个字节
        osw2.close();
    }
}

转换流理解图解

第三章 序列化

3.1 对象序列化和反序列化概述

对象序列化概念

将对象转换为字节并保持到文件中的过程

对象反序列化概念

将保持在文件中的字节读取出来并转换为对象的过程

 

3.2 ObjectOutputStream类

java.io.ObjectOutputStream 类,将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

public ObjectOutputStream(OutputStream out) : 创建一个指定OutputStream的ObjectOutputStream。

构造方法示例代码如下

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

1. 一个对象要想序列化,必须满足两个条件:

该类必须实现 java.io.Serializable 接口, Serializable 是一个标记接口,不实现此接口的类的对象在序
列化过程中会抛出 NotSerializableException 。

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public int age;
    public void addressCheck() {
    System.out.println("Address check : " + name + " ‐‐ " + address);
    }
}

2.写出对象方法

public final void writeObject (Object obj) : 将指定的对象写出

public class SerializeDemo{
    public static void main(String [] args) {
        Employee e = new Employee();
        e.name = "zhangsan";
        e.address = "beiqinglu";
        e.age = 20;
        try {
        // 创建序列化流对象
            ObjectOutputStream out = new ObjectOutputStream(new                     FileOutputStream("employee.txt"));
            // 写出对象
        out.writeObject(e);
        // 释放资源
        out.close();
        System.out.println("Serialized data is saved");
        } catch(IOException i) {
        i.printStackTrace();
        }
    }
}
输出结果:
Serialized data is saved

transient关键字

transient 关键字作用

用来修饰成员变量的,能够保证该成员变量的值不会被序列化到文件中

transient 使用格式

修饰符 transient 数据类型 变量名;

示例代码

public class Student implements java.io.Serializable {
        private String name;
        private String address;
        private transient String password;
        // .... 省略setters & getters
    }
public class SerializeDemo{
    public static void main(String [] args) {
        Student s = new Student();
        s.address = "dongguan"
        s.name = "zhangsan";
        s.password = "123456";
        try {
        // 创建序列化流对象
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("stu.txt"));
        // 写出对象
        out.writeObject(e);
        // 释放资源
        out.close();
        System.out.println("Serialized data is saved"); // password 没有被保存
        } catch(IOException i) {
        i.printStackTrace();
        }
    }
}
输出结果:
Serialized data is saved

3.3 ObjectInputStream类

ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

public ObjectInputStream(InputStream in) : 创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件,我们可以进行反序列化操作,调用 ObjectInputStream 读取对象的方法:

public final Object readObject () : 读取一个对象。

public class DeserializeDemo {
    public static void main(String [] args) {
        Employee e = null;
        try
        {
// 创建反序列化流
            FileInputStream fileIn = new FileInputStream("employee.txt");
            ObjectInputStream in = new ObjectInputStream(fileIn);
// 读取一个对象
            e = (Employee) in.readObject();
// 释放资源
            in.close();
        }catch(IOException i) {
// 捕获其他异常
            i.printStackTrace();
            return;
        }catch(ClassNotFoundException c) {
// 捕获类找不到异常
            System.out.println("Employee class not found");
            c.printStackTrace();
            return;
        }
// 无异常,直接打印输出
        System.out.println("Name: " + e.name); // zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

对于JVM可以反序列化对象,它必须是能够找到class文件的类。如果找不到该类的class文件,则抛出一个
ClassNotFoundException 异常

反序列化操作2

另外,当JVM反序列化对象时,能找到class文件,但是class文件在序列化对象之后发生了修改,那么反序列化操
作也会失败,抛出一个 InvalidClassException 异常。发生这个异常的原因如下:

该类的序列版本号与从流中读取的类描述符的版本号不匹配 。

解决序列号不匹配问题

指定一个固定的序列号

固定序列号的定义方式

private static final long serialVersionUID = 1478652478456L;
这样每次编译类时生成的serialVersionUID值都是固定的

public class Employee implements java.io.Serializable {
        // 加入序列版本号
        private static final long serialVersionUID = 1L;
            public String name;
            public String address;
            // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
            public int eid;
            public void addressCheck() {
            System.out.println("Address check : " + name + " ‐‐ " + address);
        }
}

3.4 练习:序列化集合

1. 将存有多个自定义对象的集合序列化操作,保存到 list.txt 文件中。
2. 反序列化 list.txt ,并遍历集合,打印对象信息

案例分析

1. 把若干学习对象 ,保存到集合中。
2. 把集合序列化。
3. 反序列化读取时,只需要读取一次,转换为集合类型。
4. 遍历集合,可以打印所有的学生信息

案例实现

public class SerTest {
    public static void main(String[] args) throws Exception {
// 创建 学生对象
        Student student = new Student("老王", "laow");
        Student student2 = new Student("老张", "laoz");
        Student student3 = new Student("老李", "laol");
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(student);
        arrayList.add(student2);
        arrayList.add(student3);
// 序列化操作
// serializ(arrayList);
// 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
// 读取对象,强转为ArrayList类型
        ArrayList<Student> list = (ArrayList<Student>)ois.readObject();
        for (int i = 0; i < list.size(); i++ ){
            Student s = list.get(i);
            System.out.println(s.getName()+"‐‐"+ s.getPwd());
        }
    }
    private static void serializ(ArrayList<Student> arrayList) throws Exception {
// 创建 序列化流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
// 写出对象
        oos.writeObject(arrayList);
// 释放资源
        oos.close();
    }
}

第四章 打印流

4.1 概述

平时我们在控制台打印输出,是调用 print 方法和 println 方法完成的,这两个方法都来自于
java.io.PrintStream 类,该类能够方便地打印各种数据类型的值,是一种便捷的输出方式

4.2 PrintStream类

构造方法

public PrintStream(String fileName) : 使用指定的文件名创建一个新的打印流

构造举例,代码如下:

PrintStream ps = new PrintStream("ps.txt");

改变打印流向

System.out 就是 PrintStream 类型的,只不过它的流向是系统规定的,打印在控制台上。不过,既然是流对象,
我们就可以玩一个"小把戏",改变它的流向

public class PrintDemo {
    public static void main(String[] args) throws IOException {
// 调用系统的打印流,控制台直接输出97
        System.out.println(97);
// 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
// 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
// 调用系统的打印流,ps.txt中输出97
        System.out.println(97);
    }
}

 

版权声明:本文为qq_32798905原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_32798905/article/details/81604586