【JAVADAY14-文件操作，包装流，以及序列化反序列化】

包装流的使用，特点更快更效率的读写文件

读文件（文本内容）

package File;

import org.junit.jupiter.api.Test;

import java.io.*;
import java.nio.file.Path;

public class BufferedReader01 {
    public static void main(String[] args) throws IOException {
        //包装流可以对字符数组文件处理，功能更强大，读取更快
        //下面我们来用一下包装流
        //对字节的数据最好用stream,此方法更适用于读取文本文件
        String path="E:\\Test01.txt";
        //ReaderFile(path);
        ReaderFile02(path);
    }
    @Test
    //声明一个读文件的方法，为了代码的简洁
    public static void ReaderFile(String path) throws IOException {
        if(new File(path).isFile()){
            //创建一个使用默认大小输入缓冲区的缓冲字符输入流。最好包装一下read方法，我这里是字符，所以包装了filereader对象
            BufferedReader bufferedReader = new BufferedReader(new FileReader(path));
            char[] arr=new char[100];
            int read=0;
            while ((read=bufferedReader.read(arr,0,arr.length))!=-1){
                System.out.print(new String(arr,0,read));
            }
            bufferedReader.close();
        }else {
            System.out.println("文件不存在！无法读取!");
        }
    }
    public static void ReaderFile02(String Path) throws IOException{
        if(new File(Path).isFile()){
            //创建一个使用默认大小输入缓冲区的缓冲字符输入流。最好包装一下read方法，我这里是字符，所以包装了filereader对象
            BufferedReader bufferedReader = new BufferedReader(new FileReader(Path));
            String s = null;
            //使用readline方法按行读取效率高
            while ((s=bufferedReader.readLine())!=null){
                System.out.println(s);
            }
            bufferedReader.close();
        }else {
            System.out.println("文件不存在！无法读取!");
        }
    }
}

写入内容（文本）到文件

package File;

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

public class BufferedWrite01 {
    public static void main(String[] args) throws IOException {
        String path="E:\\Test01.txt";
        Write01(path);
        Write02(path);
    }
    //方式一 默认覆盖
    public static void Write01(String path) throws IOException {
        int read=0;
        char[] chars = {'A','b','c'};
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path));
        bufferedWriter.write(chars);
        //注意此方法会覆盖掉原本的内容！！！
        //换行
        bufferedWriter.newLine();
        bufferedWriter.write(chars);
        System.out.println("添加完成");
        bufferedWriter.close();
    }
    //方式二 追加
    public static void Write02(String path) throws IOException {
        String s="我爱你";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path,true));
        //buffwrite底层添加的代码是利用filewriter的
        //因此想要追加就在filewriter添加一个true即可
        bufferedWriter.write(s);
        bufferedWriter.newLine();
        bufferedWriter.write(s);
        bufferedWriter.newLine();
        bufferedWriter.write(s);

        System.out.println("追加完成");
        bufferedWriter.close();
    }
}

文本类的拷贝

package File;

import java.io.*;

public class BufferCopy {
    public static void main(String[] args) throws IOException {
        String sourpath="E:\\JavaProject\\TnKeWar\\src\\Tnke\\Hero.java";
        String endpath="E:\\hero.java";
        //注意 下面方法只适用于复制文本类的文件 不要读取二进制文件
        copy(sourpath,endpath);
    }
    public static void copy(String sourpath,String endpath) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(sourpath));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(endpath));
        //先读取 在存放e
        String s;
        while ((s=bufferedReader.readLine())!=null){
            bufferedWriter.write(s);
        }
        System.out.println("复制完成！");
        bufferedReader.close();
        bufferedWriter.close();
    }
}

字节Buffer流

二进制文件的拷贝

package BufferByte;

import java.io.*;

public class BufferByteCopy {
    public static void main(String[] args) throws IOException {
        //这里用到的是字节处理流
        String sourpath="C:\\Users\\TMJIE5200\\Pictures\\150.png";
        String endpath="e:\\girel.png";
        Copy(sourpath,endpath);
    }
    public static void Copy(String sourpath,String endpath) throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(sourpath));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(endpath));
        byte[] bytes=new byte[1024];
        int read;
        while ((read=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,read);
        }
        System.out.println("拷贝完成");
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}

Object，序列化与反序列化

序列化

package ObjectFileStream;

import java.io.*;

public class OjectFileOutPutStream {
    public static void main(String[] args) throws IOException {
        //序列化一个类
        String path = "E:\\data.dat";
        Serializ(path);
    }

    public static void Serializ(String path) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));
        objectOutputStream.writeObject(new Animals("小明", 18, "男"));
        objectOutputStream.writeInt(100);
        objectOutputStream.close();
        System.out.println("序列化完成！");
    }
}

反序列化

package ObjectFileStream;

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

public class ObjectInputStream01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //反序列化
        String path="E:\\data.dat";
        Fun(path);
    }
    public static void Fun(String path) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(path));
        //注意顺序问题
        //即读取数据必须和输入时的顺序一致
        System.out.println("对象:"+objectInputStream.readObject());
        System.out.println("数字:"+objectInputStream.readInt());
        //如果想在反序列化时调用类的方法，必须让此类是公共类
        System.out.println(new Animals("小王",22,"女"));
        objectInputStream.close();
        System.out.println("反序列化完成！");
    }
}

上述中使用的Animals类

package ObjectFileStream;

import java.io.Serializable;

public class Animals implements Serializable {
    private String Name;
    private int Age;
    private String Sex;
    //序列化的类中建议加上下面seriaVersionUID为了提高版本的兼容性
    private static final long seriaVersionUID = 1L;

    public Animals(String name, int age, String sex) {
        Name = name;
        Age = age;
        Sex = sex;
    }

    //序列化时默认序列化所以成员，除了static 和 transient修饰的成员
    @Override
    public String toString() {
        return "Animals{" +
                "Name='" + Name + '\'' +
                ", Age=" + Age +
                ", Sex='" + Sex + '\'' +
                '}';
    }
}

序列化与反序列化细节

文件的序列化操作，即保存值和保存值对应的类型
文件的反序列化操作，根据保存的文件，恢复成原本的样子
前提：
想要实现序列化，需要在序列化的类实现下面2个接口之一

serializable（这个接口没有方法）、externalizable （这个接口有方法需要实现）标记一个类是可以序列化的

因此我们一般选择serializable

//序列化时默认序列化所以成员，除了static 和 transient修饰的成员

//序列化的类中建议加上下面seriaVersionUID为了提高版本的兼容性
private static final long seriaVersionUID=1L;

序列化类中的属性，必须实现了serializable，比如int和string 他们的包装类 Inteage 和 String 都实现了的
如果你定义了一个 private Master=new Master()，那么你在序列化时一定报错
怎么解决呢，在Mster类实现serializable即可。
序列化具有继承性，父类实现了serializable子类就默认实现了。