IO输入输出流 序列化与反序列化

2023.02.21 星期二

1 IO输入输出流

1.1 流是什么？

流是通道。
在Java中流是提供数据传输的通道。
A=================>B

1.2 流的分类

按不同的方式将流进行了不同的分类：
1 按方向:参照物是内存。
输入流和输出流。
编写一个程序，需要读文件中的内存到程序中来。需要使用输入流。
写文件用输出流。
2 按流量:
字节流和字符流
1个字符等于2个字节。
一般字符流都是用来操作文本数据。(文本文件)
一般字节流都是用来操作二进制数据。(声音，图片，视频)
最终我们可以得到流应用中的4个父类：字节输入，字节输出，字符输入，字符输出

3 扩展分类：按功能分类：
节点流和过滤流
节点流是直接操作源对象
的流对象。源对象（A和B这二个点）
过滤流是是操作流对象的流对象。为流对象附加功能。

1.3 File类

因为在Java中使用流对象，操作文件是最多的使用方式。
一个用来表示文件或目录的类。

1.3.1 构造方法

public File(String pathname)
通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
String数据类型的参数：在编写路径过程中。要使用到D:\xxx.png。在这里一定要注意“\”或”/”

File file = new File("F:/1801971.gif");

1.3.2 二个静态常量

目录分隔符：一个路径中每级目录之间的分隔
System.out.println(File.separator);

路径分隔符：多个路径之间分隔的符号
System.out.println(File.pathSeparator);

1.4 四个流父类

字节与字符。输入与输出。
在Java中为以下四个类分别创建了父类。
字节输入：InputStream
字节输出：OutputStream

字符输入：Reader
字符输出：Writer
以上的四个父类都是抽象类。都需要使用父类的子类才可以使用。

每一个子类都对应一种数据源对象。
例如：操作文件的输入流，FileInputStream。

1.5 流操作的基本流程

基本流程分三步：
1 打开流对象
2 操作流对象
3 关闭流对象（一定要执行）

1.6 FileInputStream和FileOutputStream

FileInputStream和FileOutputStream 是操作文件的字节流。
字节流每次操作一个字节。字节是byte。基本数据类型。是-128~127
字节是计算机文件的最小单位。使用字节流可以操作任意类型的文件。
一般都是用来操作像，图片，音频，视频这种二进制文件。

public static void main(String[] args) throws IOException {
    //第一步：打开
    FileInputStream fis = new FileInputStream("F:/Oracle-Cork.jpg");
    FileOutputStream fos = new FileOutputStream("F:/Cork.jpg");
    //第二步：操作
    byte[] bytes = new byte[1024];//1024个字节的数组。1KB
    int len = -1;//len表示本次读了多少个字节。
    while ((len = fis.read(bytes)) != -1) {
        fos.write(bytes,0,len);
    }
    //第三步：关闭
    fos.flush();//清空缓存
    fos.close();
    fis.close();
    System.out.println("end");
}

1.7 异常在IO操作中的应用

异常：try-catch-finally
IO操作过程中一定要有关闭的过程。一定要执行的部分。

第一版：旧的。

public static void main(String[] args){
    //第一步：打开
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream("F:/Oracle-Cork.jpg");
        fos = new FileOutputStream("F:/Cork.jpg");
        //第二步：操作
        byte[] bytes = new byte[1024];//1024个字节的数组。1KB
        int len = -1;//len表示本次读了多少个字节。
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        //第三步：关闭
        try {
            if(fos!=null) {
                fos.flush();//清空缓存
                fos.close();
            }
            if(fis!=null) {
                fis.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    System.out.println("end");
}

第二版：新的方式。
try-resources方式。
使用这种新格式，可以自动实现流对象的关闭。
try(
声明流对象，这个流对象在使用完成之后。可以自动关闭。
){
try块的代码，流对象的操作。
}cathc(Exception e){
}

public static void main(String[] args){
    try(//第一步：打开
        FileInputStream fis = new FileInputStream("F:/Oracle-Cork.jpg");
        FileOutputStream fos = new FileOutputStream("F:/Cork.jpg"); ) {
        //第二步：操作
        byte[] bytes = new byte[1024];//1024个字节的数组。1KB
        int len = -1;//len表示本次读了多少个字节。
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
    }catch (IOException e){
        e.printStackTrace();
    }
    System.out.println("end");
}

1.8 FileWriter和FileReader

FileWriter 字符输出流
FileReader 字符输入流
字符流一般用来操作文本文件。
每次读写一个字符。

1.9 BufferedReader和BufferedWriter

二个带缓存的字符输入流和字符输出流对象。
这二个是过滤流对象。不直接操作源对象。直接操作的是另一个流对象。
过滤流是对节点流功能的扩展。
Buffered是扩展的缓存

public class FileReaderTest {
    public static void main(String[] args) {
        try (FileReader fileReader = new FileReader("f:/b.txt");//节点流
             BufferedReader br = new BufferedReader(fileReader);//过滤流
        ) {
            while(br.ready()) {
                String s = br.readLine();
                System.out.println(s);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}


public class FileWriterTest {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("f:/b.txt");
             BufferedWriter bw = new BufferedWriter(fw)) {
            bw.write("这是一行文本！！");
            bw.newLine();
            bw.write("这是一行新文本！！！");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

1.10 使用第三方插件

commons-io.jar。 这是第三方提供的Jar包。
Jar包是个class文件的压缩包。可以在Java工程中导入。
当我们以后编写好了一些类。想让其他程序员也能使用。我们要做的就是将自己的Java 类打包。打成Jar包。

public class FileUtilsTest {
    public static void main(String[] args) {
        try {
            FileUtils.copyFile(
                    new File("f:/Cork.jpg"),
                    new File("f:/Cork-1.jpg"));
            System.out.println("end");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class IOUtilsTest {
    public static void main(String[] args) {
        try {
            IOUtils.copy(
                    new FileInputStream("F:/Oracle-Cork.jpg"),
                    new FileOutputStream("F:/Cork-2.jpg"));
            System.out.println("end");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.11 序列化和反序列化

1.11.1 什么叫序列化和反序列化

化：过程。
序列化：将对象保存到文件的过程称为序列化。
反序列化：从文件中读一个对象的客称为反序列化。

单机游戏有存档。
1 save 存档 序列化。
2 load 读档 反序列化。

1.11.2 序列化接口Serializable

接口表示了一种能力。当我们自己编写的类实现了某一个接口就表示具备有某一种能力。

public interface Serializable {
}

这个接口中没有任何方法。只表示了一种能力。
我们自己编写的类。实现了Serializable接口，才能被序列化和反序列化。

/**
 * Phones类实现了Serializable接口。表示Phones类可以被序列化和反序列化。
 */
public class Phones implements Serializable{
    private Integer id;
    private String name;
    private double price;

1.12.3 序列化使用的流对象

序列化操作是输入还是输出？输出。
对象的类型是很多种，所以使用字节流。
序列化是将对象保存到文件的过程。使用操作文件的流对象。
能确定第一个节点流对象：FileOutputStream。
还需要一个过滤流对象：ObjectOutputStream。

    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("f:/121.data");
             ObjectOutputStream oos = new ObjectOutputStream(fos)
        ){
            Phones phe = new Phones(1,"iphone11",6000D);
            oos.writeObject(phe);
            System.out.println("end");
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

反序列化

    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("f:/121.data");
             ObjectInputStream ois = new ObjectInputStream(fis)
        ) {
            Phones phe = (Phones) ois.readObject();
            System.out.println(phe);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }