🏡个人主页：@ 守夜人st
🚀系列专栏：Java
…持续更新中敬请关注…
🙉博主简介：软件工程专业，在校学生，写博客是为了总结回顾一些所学知识点

IO流进阶

缓冲流

缓冲流概述

缓冲流也称为高效流、或者高级流。在上一篇博客里我们学习的字节流可以称为原始流。

作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能。

字节缓冲流(BufferedInputStream字节缓冲输入流、BufferedOutputStream字节缓冲输出流)

字节缓冲输入流自带了8KB缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。

字节缓冲输出流同样自带了8KB缓冲池，数据就直接写入到缓冲池中去，写数据性能提高了。

构造器	说明
public BufferedInputStream(InputStream is)	可以把低级的字节输入流包装成一个高级的缓冲字节输入流管道
public BufferedOutputStream(OutputStream os)	可以把低级的字节输出流包装成一个高级的缓冲字节输入流管道

package com.shouyeren.oop.api.byte_stream;

import java.io.*;

/**
 * 目标：实现文件的拷贝（支持一切文件类型）
 */
public class ByteBufferDemo01 {
    public static void main(String[] args) {
        try {
            //1.创建一个字节输入流管道与源文件接通
            InputStream is = new FileInputStream("C:\\Users\\shouyeren\\Desktop\\20221227_114837.m4a");
            //包装
            InputStream bis = new BufferedInputStream(is);

            //2.创建一个字节输出流管道与源文件接通
            OutputStream os = new FileOutputStream("src/new.m4a");
            //包装
            OutputStream bos = new BufferedOutputStream(os);

            //3.定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; //记录每次读取的字节数
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
            System.out.println("文件拷贝完成！");

            //4.关闭流
            os.close();
            is.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字节缓冲流与原始字节流的不同点就在于她自带了一个8KB的缓冲池，可以提高数据的读写速度，至于功能方面没有太多变化

字符缓冲流(BufferedReader字符缓冲输入流、BufferedWriter字符缓冲输出流)

字符缓冲输入流：提高字符输入流读取数据的性能，除此之外多了按照行读取数据的功能

构造器	说明
public BufferedReader(Reader r)	可以把低级的字符输入流包装成一个高级的缓冲字符输入流管道

字符缓冲输入流新增功能

方法	说明
public String readLine()	读取一行数据返回，如果读取没有完毕，无行可读返回null

package com.shouyeren.oop.api.byte_stream;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.Reader;

public class BufferedReaderDemo01 {
    public static void main(String[] args) {
        try(
                Reader fr =new FileReader("src/data.txt");
                BufferedReader br = new BufferedReader(fr);
        ) {
                String line;
                while ((line = br.readLine()) != null){
                    System.out.println(line);
                }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

字符缓冲输出流：提高字符输出流写数据的性能，除此之外多了换行功能

构造器	说明
public BufferedWriter(Writer w)	可以把低级的字符输出流包装成一个高级的缓冲字符输出流管道

字符缓冲输出流新增功能

方法	说明
public void newLine()	换行操作

转换流

引出：如果代码编码和文件编码不一致会出现中文乱码，而转换流可以把原始的字节流按照指定编码转换成字符输入流，就可以避免因为编码不同而引起的乱码问题

字符输入转换流(InputStreamReader)

字符输出转换流(OutputStreamWriter)

构造器	说明
public InputStreamReader(InputStream is)	可以把原始的字节流按照代码默认编码转换成字符输入流，几乎不用，与默认的FileReader一样
public InputStreamReader(InputStream is,Sting charset)	可以把原始的字节流按照指定编码转换成字符输入流，完美的避免了乱码问题

package com.shouyeren.oop.api.byte_stream;

import java.io.*;

public class InputStreamReaderDemo01 {
    public static void main(String[] args) {
        //代码UTF-8 文件GBK  src/outputTest.txt
        try(
                //1.提取GBK文件的原始字节流
                InputStream is = new FileInputStream("src/outputTest.txt");
                //2.把原始字节流转换成字符输入流
                //Reader isr = new InputStreamReader(is);//默认以UTF-8转换，还是无法避免乱码问题，与FileReader是一样的
                Reader isr = new InputStreamReader(is,"GBK");//指定以GBK编码转换，避免了因编码方式不同引起的乱码问题
                BufferedReader br = new BufferedReader(isr)
                ){
                    String line;
                    while ((line = br.readLine()) != null){
                        System.out.println(line);
                    }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

OutputStreamWriter与InputStreamReader对应，也具有指定编码的功能，这里不作过多赘述。

序列化对象

对象序列化：

作用：以内存为基础，把内存中的对象存储到磁盘文件中去，称为对象序列化

使用到的流是对象字节输出流：ObjectOutputStream

构造器	说明
public objectOutputStream(OutputStream out)	把低级字节输出流包装成高级的对象字节输出流

方法名称	说明
public final void writeObject(Object obj)	把对象写出去到对象序列化流的文件中去

注意：

要实现对象序列化的对象必须实现序列化接口(Serializable)

transient修饰的成员变量不参与序列化

Student类

package com.shouyeren.oop.api.byte_stream;

import java.io.Serializable;

//对象要序列化必须实现 Serializable 接口
public class Student implements Serializable {
    private String name;
    private String loginName;
    //transient修饰的成员变量不参与序列化
    private transient String passWord;
    private int age;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public int getAge() {
        return age;
    }

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

测试类

package com.shouyeren.oop.api.byte_stream;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

//
public class ObjectOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //1.创建学生对象
        Student student = new Student("张三","zs666","123456",21);

        //2.对象序列化：使用对象字节输出流包装字节输出流管道
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/data.txt"));

        //3.直接调用序列化方法
        oos.writeObject(student);

        //4.释放资源
        oos.close();
    }
}

对象反序列化

使用到的流是对象字节输入流：ObjectInputStream

作用：以内存为基础，把存储到磁盘文件中的对象数据恢复成内存中的对象，称为对象反序列化

构造器	说明
public ObjectInputStream(InputStream in)	把低级字节输入流包装成高级的对象字节输入流

方法名称	说明
public Object readObject()	把储存到磁盘文件中去的对象数据恢复成内存中的对象返回

package com.shouyeren.oop.api.byte_stream;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * 学会对象反序列化，使用对象字节输入流把文件中的对象数据恢复为内存中的Java对象
 */
public class ObjectInputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        //1.创建对象字节输入流管道包装低级的字节输入流管道
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("src/data.txt"));

        //2.调用对象字节输入流的反序列化方法
        Student student = (Student) inputStream.readObject();
        System.out.println(student);

        //3.释放资源
        inputStream.close();
    }
}

打印流

PrintStream

作用：打印流可以实现方便、高效的打印数据到文件中去。

打印流一般是指：PrintStream、PrintWriter两个类

可以实现打印什么数据就是什么数据，例如打印整数97，写出去就是97，而不是a，打印boolean的true打印出去就是true。

打印流的使用十分方便，还可以指定编码输出

构造器	说明
public PrintStream(OutputStream os)	打印流直接通向字节输出流管道
public PrintStream(File f)	打印流直接通向文件对象
public PrintStram(String filepath)	打印流直接通向文件路径

package com.shouyeren.oop.api.byte_stream;

import java.io.PrintStream;

/**
 * 学会使用打印流方便、高效的打印数据到文件中
 */
public class PrintDemo01 {
    public static void main(String[] args) throws Exception {
        //1.创建一个打印流对象
        PrintStream printStream = new PrintStream("src/data1.txt");
        //2.打印数据
        printStream.println(97);
        printStream.println(true);
        printStream.println(33.3);
        printStream.println("打印流输出完毕...");
        
        //3.关闭资源
        printStream.close();

    }
}

97
true
33.3
打印流输出完毕...

PrintWriter

构造器	说明
public PrintWriter(OutputStream os)	打印流直接通向字节输出流管道
public PrintWriter(Writer w)	打印流直接通向字符输出流管道
public PrintWriter(File f)	打印流直接通向文件对象
public PrintWriter(String filepath)	打印流直接通向文件路径

PrintStream 与 PrintWriter的区别

打印数据的功能上是一模一样的，都是使用方便，性能高效

PrintStream 继承自字节输出流 OutputStream，支持写字节数据的方法

PrintWriter 继承自字符输出流 Writer ，支持写字符数据

Properties

Properties 属性集对象

其实就是一个Map集合，但是我们一般不会当集合使用，因为HashMap更好用

Properties 核心作用：

Properties代表的是一个属性文件，可以把自己对象中的键值对信息存入到一个属性文件中去

属性文件：后缀是.properties结尾的文件，里面的内容都是 key = value，做系统配置信息的文件

public class PropertiesDemo01{
    public static void main(String[] args)throws Exception{
        //需求：使用Properties把键值对信息存入到属性文件中去
        Properties properties = new Properties();
        properties.setProperty("admin","123456");
        properties.setProperty("zhangsan","123456");
        properties.setProperty("lisi","123456");
        /**
        	参数一：保存管道 字符输出流管道
        	参数二：注释信息
        */
        //加载方法 ——load(FileReader对象)
        //存储方法
        properties.store(new FileWriter("文件路径")，"注释信息");
        
    }
}

IO框架

commons-io概述

commons-io是apache开源基金组织提供的一组有关IO操作的类库，可以提高IO功能开发的效率

commons-io工具包提供了很多有关IO操作的类。有两个主要的类FileUtils,IOUtils

FileUtils主要有如下方法：

方法名	说明
String readFileToString(File file,String encoding)	读取文件中的数据，返回字符串
void copyFile(File srcFile,File destFile)	复制文件
void copyDirectoryToDirectory(File secDir ,File destDir)	复制文件夹

从JDK1.7开始Java也实现新的IO升级(NIO),以前繁琐的IO操作大多都能一行代码实现了。

总结

文件专属：                                                                     数据流专属：          

FileInputStream                                                              DateInputStream

FileOutputStream                                                           DateOutputStream

FileReader                                                                      标准输出流：       

FileWriter                                                                         PrintWriter

缓冲专属:                                                                         PrintStream

BufferedReader                                                               转换流（将字节流转换成字符流）:

BufferedWriter                                                                 InputStreamReader

BufferedInputStream                                                       OutputStreamWriter

BufferedOutputStream 

                        对象专属流：ObjectInputStream        ObjectOutputStream