缓冲流、转换流、基本数据类型流、对象流、commons-IO流

1.缓冲流

缓冲流属于功能流中的一种，本身不具有操作数据的功能，主要用来增强节点流的读写效率，提高节点流的性能。

功能流的形参是节点流：功能流（节点流）；

常用字节、字符缓冲流：

节点流	功能流
InputStream	BufferedInputStream——字节输入缓冲流
OutputStream	BufferedOutputStream——字节输出缓冲流
Reader	BufferedReader——字符输入缓冲流
Writer	BufferedWriter——字符输出缓冲流

        //缓冲流增强节点流的读写能力，提高效率
		InputStream is = new BufferedInputStream(new FileInputStream("C://AAA//test.txt"));
        OutputStream os = new BufferedOutputStream(new FileOutputStream("C://AAA//test2.txt"));
		//创建字节数组存放读入的数据
        byte[] arr = new byte[3];
        int len = -1;
		//写入数据，len判断条件
        while((len=is.read(arr))!=-1){
            os.write(arr,0,len);
        }
		//输出流刷出
        os.flush();
		//输出流关闭
        os.close();
		//输入流关闭
        is.close();

2.转换流

转换流也是功能流的一种，主要用来将字节输入输出转换为字符的输入输出。

• InputStreamReader——>字节输入转字符输入;
• OutputStreamWriter——>字节输出转字符输出;

		//字符缓冲流（字符转换流（字节缓冲流（字节流）））
		BufferedReader rd = new BufferedReader(new InputStreamReader(new BufferedInputStream(new FileInputStream("C://AAA//test.txt"))));
        BufferedWriter wt = new BufferedWriter(new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream("C://AAA//test3.txt"))));
        String msg = null;
		//字符流的新方法，读取单行，返回字符串
        msg = rd.readLine();
        wt.write(msg);
        wt.flush();
        wt.close();
        rd.close();

3.基本数据类型

属于字节流功能流的一种，其能够使节点流具有传输基本数据类型+数据的能力。

• DataInputStream——>基本数据类型输入流；
• DataOutputStream——>基本数据类型输出流；

		//数据类型输出流对象
		DataOutputStream  dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("D://aaa.txt")));
		//数据类型输入流对象
        DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("D://aaa.txt")));
		//能够对基本数据类型进行读写操作
        int i = 10;
        char c = 'a';
        boolean flag = false;
        String s = "string";
        dos.writeBoolean(flag);
        dos.writeUTF(s);
        dos.writeChar(c);
        dos.writeInt(i);
        dos.flush();
        dos.close();			System.out.println(dis.readUTF()+","+dis.readInt()+","+dis.readBoolean());
        dis.close();

4.对象流

Object流流能够读写所有类型和对象。

• ObjectInputStream——>对象字节输入流——反序列化输入流；
• ObjectOutputStream——>对象字节输出流——序列化输出流；

序列化：java对象类型的信息状态转换成一个可存储，可传输的信息状态的过程。

public class BufferedIn {

    public static void main(String[] args) throws Exception {
        Demo("D://ABC.txt");

public static void Demo(String desc) throws Exception {
    	//创建Student对象
        Student s = new Student("小白",15,1520);
        System.out.println(new File(desc).exists());
		//创建对象流输出流对象
        OutputStream i = new FileOutputStream(desc);
        ObjectOutputStream obos = new ObjectOutputStream(new BufferedOutputStream(i));
    	//写入Student类对象
        obos.writeObject(s);
		//注意此时，写入完毕后需要立即进行刷出操作，否则会报错
        obos.flush();
		//新建对象输入流对象
        InputStream is = new BufferedInputStream(new FileInputStream(desc));
        ObjectInputStream obis = new ObjectInputStream(is);


        Student s2 = (Student) obis.readObject();
        System.out.println(s2.toString());

        obos.close();
        obis.close();

    }
}

import java.io.Serializable;
import java.util.Objects;

public class Student implements Serializable {
    //增加序列号后，对Student类的属性进行修改后，同样还可以读取该数据
    private static final long serialVersionUID = 4088760543736495002L;
    private static String name;
    private int age;
    private transient int id;
    private int sno;

    public Student(){

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

    public static String getName() {
        return name;
    }

    public static void setName(String name) {
        Student.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                id == student.id;
    }
}

注意：

读写数据的顺序要一致；

• 不是所有的类型的对象都可以序列化，需要实现Serializable接口；
• 不是所有属性都需要序列化，transient关键字修饰的属性不会被序列化，static修饰的成员不会被序列化；
• 子类实现了序列化接口，子类只能序列化自己的内容，不能序列化父类中继承的内容；

5.commons-IO流

commons-IO流是工具类IO流，其中将很多功能封装，需要下载jar包，并将包放在项目中，使用时导包即可。

public class CommonsIODemo01 {
    public static void main(String[] args) throws IOException {
        //文件的拷贝
        //IOUtils.copy(InputStream input, OutputStream output)  自定义使用什么流
        //FileUtils.copyFile(File srcFile, File destFile) // 复制文件
        FileUtils.copyFile(new File("D:/test.txt"),new File("D:/c.txt"));
        IOUtils.copy(new FileInputStream("D:/test.txt"), new FileOutputStream("D:/d.txt"));

        //FilenameUtils.getExtension(String filename)
        System.out.println(FilenameUtils.getExtension("D://haha123.txt.java"));

        //FileUtils.copyDirectory(File srcDir, File destDir) // 复制文件夹（文件夹里面的文件内容/也会复制） 注意:目的地需要完整路径
        //FileUtils.copyDirectory(new File("D://AAA"),new File("D://HEHE/AAA"));

        //FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter) // 复制文件夹，
        //带有文件过滤功能  了解
        FileUtils.copyDirectory(new File("D://AAA"),new File("D://HEHE/AAA"), FileFilterUtils.fileFileFilter());
    }
}