【Java】（二十三）IO框架：流的概念与分类，字节流（对象流【序列化、反序列化】），编码方式，字符流（打印流，转换流）

开始学习JavaIO框架。
视频学习资料：千锋教育_Java入门基础教程视频—（IO框架）

Java-I/O框架主要学习：
1.流的概念
2.流的分类
3.字节流
4.编码方式
5.字符流
6.File类

1 流的概念与分类

1. 流的概念：内存与存储设备之间传输数据的通道。
   水借助管道传输≈数据借助流传输。
2. 流的分类
   （1）按方向【重点】
   输入流：将<存储设备>中的内容读入到<内存>中。
   输出流：将<内存>中的内容写入到<存储设备>中。
   （2）按单位
   字节流：以字节为单位，可以读写所有数据。
   字符流：以字符为单位，只能读写文本数据。
   （3）按功能
   字节流：具有实际传输数据的读写功能。
   过滤流：在节点流的基础之上增强功能。

2 字节流

存储在java.io包中。【之前都在java.lang包】

字节流的父类（抽象类）：

//InputStream 字节输入流
public int read(){}//从输入流读取下一个数据字节;已到达流的末尾，则返回-1
public int read(byte[] b){}从输入流中读取字节数组长度的字节数据存入数组中，返回实际读到的字节数；如果达到文件的尾部，则返回-1。
public int read(byte[] b, int off, int len){}//b缓冲区; off起始偏移;len最大字节数

// OutputStream 字节输出流
public void write(int n){}//将指定字节写入输出流。
public void write(byte[] b){}//一次写多个字节，将b数组中所有字节，写入输出流。
public void write(byte[] b, int off, int len){}

对文件读写时，容易出现异常IOException，可以在main方法中提前抛出throws Exception。

2.1 文件字节流

• FileInputStream文件输入流
  public int read()//从输入流中读取一个字节数据，返回读到的字节数据，如果达到文件末尾，返回-1。
  public int read(byte[] b)//从输入流中读取字节数组长度的字节数据存入数组中，返回实际读到的字节数；如果达到文件的尾部，则返回-1。
• FileOutputStream文件输出流
  public void write(int b)//将指定字节写入输出流。
  public void write(bute[] b)//一次写多个字节，将b数组中所有字节，写入输出流。

文件输入：

package stream.bytestream;

import java.io.FileInputStream;

public class FileInText {
    public static void main(String[] args) throws Exception{
        //创建流并指定文件路径
        FileInputStream in = new FileInputStream("E:\\code\\JAVA\\a.txt");//可能出现读取错误异常

        //read()读入单个字节
        int date = 0;
        while((date=in.read())!=-1){
//            System.out.print(date);//ASCII码
            System.out.print((char)date);
        }

        //read(byte[] b);读入多个字节
        byte[] b = new byte[1024];//自定义字节数
        int count = 0;
        while ((count=in.read(b))!=-1){
            System.out.println(new String(b, 0, count));
            //b是这个数组的值(一次读几个)，0是指从length=0开始读取流，count指到count时候停止读取
        }

        //关闭
        in.close();
    }
}
/*
Hello world.
Hello Java.
 */

文件输出：

package stream.bytestream;

import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

public class FileOutText {
    public static void main(String[] args) throws Exception {
        //创建输出流
        FileOutputStream out = new FileOutputStream("E:\\code\\JAVA\\b.txt");
        //写入文件
        out.write(97);//ASCII码，代表字符‘a'
        out.write('b');//写入一个字符
        String s = new String(" Hello,Java");
        out.write(s.getBytes(StandardCharsets.UTF_8));
        //关闭流
        out.close();
    }
}
/*
ab Hello,Java
 */

文件复制（一边输入一边输出）：

package stream.bytestream;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class CopyText {
    public static void main(String[] args) throws Exception {
        //将图片读取到输入流
        FileInputStream fileInputStream = new FileInputStream("E:\\code\\JAVA\\01.jpg");
        //从输出流写入数据
        FileOutputStream fileOutputStream = new FileOutputStream("E:\\code\\JAVA\\02.jpg");

        int count;//保存一次读取到的实际个数
        byte[] b = new byte[1024];

        while ((count = fileInputStream.read(b)) != -1) {
            fileOutputStream.write(b, 0, count);
        }
        System.out.println("复制成功");

        //关闭流
        fileInputStream.close();
        fileOutputStream.close();
    }
}

2.2 字节缓冲流

1. 缓冲流：BufferedInputStream/BufferedOutputStream
2. 特点：
   （1）提高IO效率，减少访问磁盘的次数；
   （2）数据存储在缓冲区中。flush()（“刷新”）可以将缓存区的内容写入文件，也可以直接close()关闭流【关闭时自动调用flush()】。

从缓冲区读入：

package stream.bytestream;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class BufferText1 {
    public static void main(String[] args) throws Exception {
        //从硬盘读取的输入流对象
        FileInputStream in = new FileInputStream("E:\\code\\JAVA\\a.txt");
        //从磁盘读入到缓冲区
        BufferedInputStream bu = new BufferedInputStream(in);

//        //从缓冲区读入，默认缓冲区大小8192(8K)
//        int date;
//        while ((date = bu.read()) != -1) {
//            System.out.print((char) date);
//        }

        //自己创建一个缓冲区；
        //每次读取从自己创建的缓冲区中读取。
        int count;
        byte[] buf = new byte[1024];
        while ((count = bu.read(buf)) != -1) {
            System.out.println(new String(buf, 0, count));
        }

        bu.close();//关闭缓冲区会自动关闭输入流对象，不需要再单独关闭

    }
}
/*
Hello world.
Hello Java.
 */

从缓冲区写出：

package stream.bytestream;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

public class BufferText2 {
    public static void main(String[] args) throws Exception{
        //文件输出对象
        FileOutputStream out = new FileOutputStream("E:\\code\\JAVA\\c.txt");
        //文件输出缓冲区
        BufferedOutputStream bu = new BufferedOutputStream(out);

        //写入缓冲区并刷新
        for (int i = 0; i < 10; i++) {
            bu.write("Helle,Java!".getBytes(StandardCharsets.UTF_8));
            bu.flush();
        }

        bu.close();
    }
}

2.3 对象流

1. 对象流：ObjectOutputStream/ObjectInputStream
   用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
2. 特点：
   （1）增加了缓冲区功能。
   （2）增强了读写8种基本数据类型和字符串功能。
   （3）增强了读写对象的功能。
3. 使用流传输对象的过程称为序列化、反序列化。
   序列化：数据转为二进制流。创建一个ObjectOutputStream调用writeObject() 输出可序列化对象。注意写出一次，操作flush() 一次。
   反序列化：二进制流还原为数据。创建一个ObjectInputStream调用readObject()读取流中的对象。
4. 注意点：
   （1）序列化类必须要实现Serializable接口（此接口内什么都没有，只是一个序列化标识）。序列化类中对象属性也要求实现Serializable接口。
   （2）serialVersionUID属性序列化版本号ID，可以保证序列化的类和反序列化的类是同一个类，不同的平台默认提供的序列化版本号多数情况下不会相同，为了避免反序列化时出错，需要指定。
   （3）不能序列化static（静态）和transient（瞬间）修饰的成员变量。
   （4）序列化多个对象,可以借助集合实现。

建一个Student类作为对象：

package study.io.objectstream;

import java.io.Serializable;

//实现接口Serializable标明类可以序列化
public class Student implements Serializable {
    //序列化的类需要显式声明序列化版本标识符
    private static final long serialVersionUID = 123L;

    String name;
    transient int age;//transient修饰的属性不可序列化
    static int height;//静态属性不可序列化

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

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

序列化：

package study.io.objectstream;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

//序列化：数据转为二进制流
public class Output {
    public static void main(String[] args) throws Exception{
        //定一个文件输出流，用来写文件。这个文件后缀名表示二进制文件，但你可以写成其他如obj等任意后缀
        FileOutputStream fos = new FileOutputStream("G:\\Java\\student.obj");
        //用文件输出流构造对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //向流中写对象
        Student s1 = new Student("Louis", 22);
        Student s2 = new Student("Levics", 18);
        Student s3 = new Student("Coco", 18);
        ArrayList<Student> students = new ArrayList<>();//用一个集合存储多个对象
        students.add(s1);
        students.add(s2);
        System.out.println(students);//[Student{name='Louis', age=22}, Student{name='Levics', age=18}]
        oos.writeObject(students);//写入多个对象的列表
        oos.writeObject(s3);//写入单个对象

        oos.close();//自动调用flush()刷新
        System.out.println("序列化完成");
    }

}

反序列化：

package study.io.objectstream;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;

//反序列化：二进制流还原为数据
public class Input {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("G:\\Java\\student.obj");
        ObjectInputStream ois = new ObjectInputStream(fis);

        //读取流中数据,只能依次读，不会重读
        ArrayList<Student> list = (ArrayList<Student>)ois.readObject();
        Student s = (Student)ois.readObject();

        ois.close();
        System.out.println("反序列化完成");
        System.out.println(list.toString());
        System.out.println(s.toString());
    }
}


/*
反序列化完成
[Student{name='Louis', age=0}, Student{name='Levics', age=0}]
Student{name='Coco', age=0}
 */

3 编码方式

编码方式	说明
IOS-8859-1	收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。采用1个字节来表示，最多只能表示256个字符。
UTF-8	针对Unicode码表的可变长度字符编码。国际上使用的编码，也称为“万国码”，收录了几乎所有国家的常用字符。采用1至3个字节来表示一个字符。
GB2312	简体中文，采用1个或2个字节来表示字符，95年之前所采用的编码。
GBK	简体中文的扩充，GB2312的升级版本。
BIG5	台湾，繁体中文。

当编码方式和解码方式不一致时，会出现乱码。假如文件内容不是字母而是“我爱中国”这样的汉字，那么使用字节流读取出来的信息就是乱码。因为字节流按字节输入输出，而这四个汉字占了12个字节，把一个汉字按一个一个字节读入自然会出现问题，这时就需要使用字符流。

查看文本编码方式：

4 字符流

字符类的父类（抽象类）：

//reader 字符输入流
public int read(){}//从流中读取单个字符，用整型来返回读取的字符；当读到流底部时返回-1。
public int read(char[] c){}//从流中读取字符保存到c数组中，返回读取的字符个数，当读到流底部时返回-1。
public int read(char[] b, int off, int len){}//抽象方法。

//Writer 字符输出流
public void write(int n){}//写入单个字符，只能写入包含16位低阶字节的整型数值，16位高阶字节将会被忽略。
public void write(String str){}//写入一个字符串。
public void write(char[] c){}//写入一个字符数组。

• 字符流适用于含有汉字的文本读取，但不能复制图片或二进制文件（01字符串）。
• 字节流可以复制任意文件。

4.1 文件字符流

• FileReader文件字符输入流：
  public int read(char[] c)//从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数;如果达到文件的尾部，则返回-1。
• FileWrite文件字符输出流r：
  public void write(String str)//一次写多个字符，将b数组中所有字符，写入输出流。

文件输入：

package study.io.file;

import java.io.FileReader;

//文件字符输入流
public class FileReaderText {
    public static void main(String[] args) throws Exception{
        FileReader fr = new FileReader("G:\\Java\\a.txt");

//        //单个字符读取
//        int date;
//        while((date=fr.read())!=-1){
//            System.out.print((char)date);
//        }
//        System.out.println(" ");

        //自建缓冲区域读取多个字符
        char[] buf = new char[1024];
        int count;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf, 0, count));
        }

        fr.close();
        System.out.println("【读取完毕】");
    }
}
/*
为共产主义事业奋斗终身！

【读取完毕】
 */

文件输出：

package study.io.file;

import java.io.FileWriter;

//文件字符输出流
public class FileWriterText {
    public static void main(String[] args) throws Exception {
        FileWriter fw = new FileWriter("G:\\Java\\b.txt");

        for (int i = 0; i < 10; i++) {
            fw.write("为可持续发展贡献力量！\n");
        }

        fw.close();
        System.out.println("【写入完毕】");
    }
}

文件复制：（使用FileReader和Filewriter复制文本文件，不能复制图片或二进制文件。）

package study.io.file;

import java.io.FileReader;
import java.io.FileWriter;

//使用FileReader和Filewriter复制文本文件,不能复制图片或二进制文件
public class FileCopy {
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("G:\\Java\\b.txt");
        FileWriter fw = new FileWriter("G:\\Java\\b2.txt");

        char[] ch = new char[1024];
        int count;
        while ((count=fr.read(ch))!=-1){
            fw.write(new String(ch, 0, count));
        }

        fr.close();
        fw.close();
        System.out.println("【复制完成】");
    }
}

4.2 字符缓冲流

1. 缓冲流：BufferedReader/BufferedWriter
2. 特点：
   （1）高效读写
   （2）支持输入换行符newLine()
   （3）可一次写一行、读一行readLine()

借助缓冲流按行读取并复制：

package study.io.file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

//字符缓冲流
public class BufferReaderText {
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("G:\\Java\\a.txt");
        BufferedReader br = new BufferedReader(fr);
        FileWriter fw = new FileWriter("G:\\Java\\a2.txt");
        BufferedWriter bw = new BufferedWriter(fw);

//        //默认缓冲区读取
//        int date;
//        while((date=br.read())!=-1){
//            System.out.print((char)date);
//        }

        //实现按行读取并写入
        String line = null;
        while((line=br.readLine())!=null){
            System.out.println(line);
            bw.write("自信从容迈向未来");
            bw.newLine();//相当于一个换行符\r \n
            bw.write(line);
        }

        br.close();
        bw.close();
        System.out.println("【复制完毕】");
    }
}

4.3 打印流

1. 实现类：PrintWriter
2. 特点：
   （1）封装了print() / println()方法，支持写入后换行。
   （2）支持数据原样打印

package study.io.file;

import java.io.PrintWriter;

//字符打印流
public class printText {
    public static void main(String[] args) throws Exception{
        PrintWriter pw = new PrintWriter("G:\\Java\\print.txt");

        //支持数据原样打印
        pw.print(97);//97
        pw.print("b");
        pw.println("ok");//换行
        pw.println("你好");

        pw.close();
    }
}
/*
97bok
你好

 */

4.4 转换流

1. 桥转换流: InputStreamReader/OutputStreamWriter。
2. 特点：
   （1）可将字节流转换为字符流。
   （2）可设置字符的编码方式。

用转换流读取汉字字符并设置编码方式：

package study.io.file;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

//转换流
public class StreamReader {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("G:\\Java\\a.txt");//字节流
        InputStreamReader isr = new InputStreamReader(fis, "utf-8");
        FileOutputStream fos = new FileOutputStream("G:\\Java\\turn.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");

        char[] ch = new char[1024];
        int count;
        while((count=isr.read(ch))!=-1){
            System.out.println(new String(ch, 0, count));
            osw.write(new String(ch, 0, count));
        }

        isr.close();
        osw.close();
        System.out.println("【转换完成】");
    }
}