Java --> IO流进阶（缓冲流、转换流、对象序列化、Properties、commons-io框架）

 

 

• 缓冲流

import java.io.*;

//使用字节缓冲流完成数据的读写操作
public class ByteBufferDemo {
    public static void main(String[] args) throws Exception{
        try(
        //这里边放置资源对象，用完后会自动关闭（即使出现异常）
        //以防出现在代码块上边出现异常导致两个管道都为null ,如：此处出现 System.out.prinln(10 / 0);
        InputStream inputStream = new FileInputStream("D:\\Intellij_IDEA_install\\resourse_imgs\\beach.jpeg");
        //1.add : 把原始的字节输入流包装成高级的缓冲字节输入流
        InputStream bufferedInputStream = new BufferedInputStream(inputStream);


        //创建字节输出流管道与目标文件接通
        OutputStream outputStream = new FileOutputStream("D:\\Intellij_IDEA_install\\resourse_imgs\\beach2.jpeg");
        //2.add : 把原始的字节输出流管道包装成高级的缓冲字节输出流管道
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);

        //int age = 9; //这样的代码防止在这里是不被允许的，只能放置资源，而所谓的资源，就是实现了AutoCloseable接口
        //创建字节输入流管道与原视频接通
        ) {
            //定义一个字节数组转移数据
            byte[] bytes = new byte[1024];
            int len = 0; //len 用于记录每次读取到的数据个数（读多少倒多少，防止最后的一组数据装不满）
            //使用缓冲流进行读取
            while ((len = bufferedInputStream.read(bytes)) != -1 ){
                bufferedOutputStream.write(bytes,0,len);
            }
            System.out.println("复制完成");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

•  字节缓冲流的性能分析
• 需求 : 分别使用低级字节流和高级字节缓冲流拷贝视频，记录耗时
• 分析：

1. 使用低级的字节流按照一个一个字节的形式复制文件；
2. 使用低级的字节流按照一个一个字节数组的形式复制文件；
3. 使用高级的缓冲流按照一个一个字节的形式复制文件；
4. 使用高级的缓冲流按照一个一个字节数组的形式复制文件

import java.io.*;

public class ByteBufferTimeDemo {
    public static final String SRC_FILE = "D:\\tencent\\QQ\\MobileFile\\src_video.mp4";
    public static final String DEST_FILE = "D:\\tencent\\QQ\\MobileFile\\"; //灵活(拷贝4次)

    public static void main(String[] args) {
//        使用低级的字节流以一个一个字节的形式复制文件
        //byteCopyOneByOne();  //太慢了啊~~~
//        使用低级的字节流以一个一个字节数组的形式复制文件
        byteArrayCopy();
//        使用高级的缓冲流一个一个字节的形式复制文件
        superBufferStream();
//        使用高级的缓冲流以一个一个数组的形式复制文件
        superBufferStreamArrayCopy();
    }

    private static void superBufferStreamArrayCopy() {
        //定义开始时间
        long startTime = System.currentTimeMillis();
        try (
                //创建字节输入流与源文件接通
                InputStream inputStream = new FileInputStream(SRC_FILE);
                //使用高级的缓冲流包装低级流
                InputStream bufferedInputStream = new BufferedInputStream(inputStream);
                //创建字节输出流与目标文件接通
                OutputStream outputStream = new FileOutputStream(DEST_FILE + "video4.mp4");
                //使用高级的缓冲流包装低级流
                OutputStream bufferedOutputStream = new BufferedOutputStream(outputStream)
        ){
            //创建数组定义每次可以复制的字节数
            byte[] bytes = new byte[1024];
            //循环读取，len表示每次可以读取到的字节数
            int len = 0;
            while (( len = bufferedInputStream.read(bytes)) != -1){
                bufferedOutputStream.write(bytes,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        //定义结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("使用高级的缓冲流以一个一个数组的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s" );
    }

    private static void superBufferStream() {
        //定义开始时间
        long startTime= System.currentTimeMillis();
        try(
                //创建字节输入流管道与源文件接通
                InputStream inputStream = new FileInputStream(SRC_FILE);
                //把低级的流包装成字节缓冲流
                InputStream bufferedInputStream = new BufferedInputStream(inputStream);
                //创建字节输出流管道与目的文件接通
                OutputStream outputStream = new FileOutputStream(DEST_FILE + "video3.mp4");
                //低级的字节输出流管道包装成缓冲字节输出流
                OutputStream bufferedOutputStream = new BufferedOutputStream(outputStream)
                ){
            //循环读取，定义len记录每次读取到的字节数
            int len = 0;
            while((len = bufferedInputStream.read()) != -1){
                bufferedOutputStream.write(len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        //定义结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("使用高级的缓冲字节流以一个一个字节复制的形式耗时：" + (endTime - startTime)/1000.0 + "s");
    }

    private static void byteArrayCopy() {
        //记录开始时间
        long startTime = System.currentTimeMillis();
        try(
                //创建字节输入流管道与源文件接通
                InputStream inputStream = new FileInputStream(SRC_FILE);
                //创建字节输出流管道与目的文件接通
                OutputStream outputStream = new FileOutputStream(DEST_FILE + "video2.mp4")
                ){
            //创建字节数组定义每次可以复制的数据
            byte[] bytes = new byte[1024]; //1k
            //定义变量len用于记录每次读取到的字节个数（读多少倒多少）
            int len = 0;
            while((len = inputStream.read(bytes)) != -1){
                outputStream.write(bytes,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("使用低级的字节流以一个一个字节数组的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }

    private static void byteCopyOneByOne() {
        //开始时间毫秒值
        long startTime = System.currentTimeMillis();
        try(
                //1、创建字节输入流管道与目标文件接通
                InputStream inputStream = new FileInputStream(SRC_FILE);
                //2、创建字节输出流管道与目的文件接通
                OutputStream outputStream = new FileOutputStream(DEST_FILE + "video1.mp4");
                ){
            //定义变量len记录每次读取到的字节数
            int len = 0;
            while ((len = inputStream.read()) != -1){
                outputStream.write(len);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        //结束时间毫秒值
        long endTime = System.currentTimeMillis();
        System.out.println("使用低级的字节流以一个一个字节的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }
}

示例程序运行结果（注：由于CPU不同时间的运算效率都不相同，所每次运行的结果都或多或少会有些许差异）：

 由于改视频文件有一亿八千多万字节（意味着要循环一亿八千多玩次），所以一个一个字节复制实在是太慢了，所以在此处就把改方法屏蔽掉了：

 

 

 相对来说，所定义的字节数组越大，文件的复制速度就会越快。但是也并非绝对，如果把定义的数组大小比作一个桶，数据比作池子，相对来说是桶越大，装水的速度是越快，但是需要明白的一点是：桶大了之后那么取水和装水的速度会相应地增加，所以说在一定地情况下，尽可能地把桶定义地大一点有利于文件地复制速度。【一般字节是1kb，即1024个byte】。

总结：目前来看，如果要读写文件数据，使用字节缓冲输入流、字节缓冲输出流，结合字节数组的方式，性能是最好的。

• 缓冲字符输入流

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

//使用缓冲字符输入流提高输入流的性能,新增了按照行读取的方法
public class BufferedReaderDemo1 {
    public static void main(String[] args) {

        try(
                //创建文件字符输入流管道与源文件接通
                Reader reader = new FileReader("file-io-app\\src\\data06.txt");
                //将低级的字符输入流管道包装成高级的缓冲字符输入流
                //Reader bufferedReader = new BufferedReader(reader);

                //readLine:使用子类独有的功能时不能用多态的写法
                BufferedReader bufferedReader = new BufferedReader(reader)
        ) {
//            //创建字节数组定义每次可以读取到的字节个数
//            char[] chars = new char[1024];
//            //定义变量用于记录每次读取到的字符个数
//            int len = 0;
//            while ((len = bufferedReader.read(chars)) != -1){
//                String str = new String(chars,0,len);
//                System.out.print(str);

            //按照行进行读取（JDK8开始）
            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line); //因为是按行读取的（一行行读），所以此处需要换行
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

•  缓冲字符输出流

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;

//缓冲字符输出流的使用
public class BufferedWriterDemo2 {
    public static void main(String[] args) {
        try(
                //创建字符输出流管道与目标文件接通 【注：如果是追加管道在原始流的构造器里边添加true】
                //Writer writer = new FileWriter("io-app2\\src\\out1.txt",true);
                Writer writer = new FileWriter("io-app2\\src\\out1.txt");
                //把低级的字符输出流管道包装成高级的缓冲字符输出流管道
                BufferedWriter bufferedWriter = new BufferedWriter(writer)
        ){
            bufferedWriter.write("各种各样的数据：单个字符、字符数组、字符串、基本数据类型的数据");
            bufferedWriter.newLine(); //换行新方法
            bufferedWriter.write("第二行");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

由于写法和之前的字符输出流类似，功能也只是套了层壳而已，所以就不再一 一演示各种类型的数据了。

•  案例：拷贝出师表到另一个文件，回复顺序
• 需求：把《出师表》的文章顺序进行回复到一个新的文件中去。

分析：

1. 定义一个缓冲字符输入流管道与源文件接通；
2. 定义一个List集合存储读取到的每行数据；
3. 定义一个循环按照行读取数据、存入到List集合中去；
4. 对List集合中的每行数据按照首字符编号进行排序；
5. 定义一个缓冲字符输出流管道与目标文件接通；
6. 定义List集合中的每个元素，用缓冲输出流管道写出并换行。

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class BufferedCharTest3 {
    public static void main(String[] args) {
        try (
                //定义一个字符输出流管道与源文件接通
                Reader reader = new FileReader("io-app2\\src\\csb.txt") {
                };
                //把低级的流包装成高级的字符缓冲输出流
                BufferedReader bufferedReader = new BufferedReader(reader)
        ) {
            //定义List集合存储读取到的数据
            List<String> datas = new ArrayList<>();
            String str;
            while ((str = bufferedReader.readLine()) != null){
                datas.add(str);
            }
            System.out.println(datas);
            Collections.sort(datas);
            datas.forEach(s -> System.out.println(s));
            //System.out.println(datas);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

csb.txt文件内容：

 

 程序运行结果：

 

•  在上述示例中，没行数据的标号用的都是阿拉伯数字1~9，如果是汉字 一 ~ 九会怎么样呢？

首先：对csb.txt中的内容做少许的改动：

 

import java.io.*;
import java.util.*;

public class BufferedCharTest3 {
    public static void main(String[] args) {
        try (
                //定义一个字符输入流管道与源文件接通
                Reader reader = new FileReader("io-app2\\src\\csb.txt");
                //把低级的流包装成高级的字符缓冲输出流
                BufferedReader bufferedReader = new BufferedReader(reader);

                //定义缓冲字符输出流管道与目标文件接通
                Writer writer = new FileWriter("io-app2\\src\\new_csb.txt");
                //用高级的缓冲字符输出流管道包装低级的字符
                BufferedWriter bufferedWriter = new BufferedWriter(writer)
        ) {
            //定义List集合存储读取到的数据
            List<String> datas = new ArrayList<>();
            String str;
            while ((str = bufferedReader.readLine()) != null){
                datas.add(str);
            }
            System.out.println(datas);
            //自定义排序规则
            List<String> numbers = new ArrayList<>();
            Collections.addAll(numbers,"一","二","三","四","五","六","七","八","九","十","十一","十二");
            Collections.sort(datas, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return numbers.indexOf(o1.substring(0,o1.indexOf("."))) -
                            numbers.indexOf(o2.substring(0,o2.indexOf(".")));
                }
            });
            datas.forEach(s -> System.out.println(s));

            for (String data : datas) {
                bufferedWriter.write(data);
                bufferedWriter.newLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

new_csb.txt文件中的内容：

 至此，便实现了自定义排序规则。

•  代码与文件编码不一致导致读取乱码的问题、转换流来解决
• 步骤一：使用相同编码读取不同编码的文件内容
• 需求：分别以如下两种方式读取文件内容

1. 代码编码是UTF-8，文件编码也是UTF-8，使用字符流读取观察输出的中文结果。
2. 代码编码是UTF-8，文件编码是GBK，使用字符流读取观察输出的中文字符结果。

文件编码格式更改：【ANSI ： 使用两个字节表示中文字符，一个字节表示英文字符】

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

public class CharSetTest1 {
    public static void main(String[] args) {
        try(
                //代码：UTF-8,文件：UTF-8不会出现乱码
//                //创建字符输入流管道与源文件接通
//                Reader reader = new FileReader("io-app2\\src\\api_reader.txt");

                //代码：UTF-8（三个字节 --> 一个字符）,文件：ANSI，出现乱码（两个字节 --> 一个字符）
                //创建字符输入流管道与源文件接通
                Reader reader = new FileReader("D:\\Intellij_IDEA_install\\resourse_imgs\\love.txt");
                //把低级的字符输入流包装成高级的缓冲字符输入流
                BufferedReader bufferedReader = new BufferedReader(reader);
                ){
            String str = null;
            while ((str = bufferedReader.readLine()) != null){
                System.out.println(str);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

示例代码运行结果（由于代码编码和文件编码不一致造成的乱码问题）

 

import java.io.*;

public class InputStreamReaderDemo1 {
    public static void main(String[] args) {
        //代码：UTF-8，文件：ANSI
        try(
                //提取ANSI文件的原始字节流
                InputStream inputStream = new FileInputStream("D:\\Intellij_IDEA_install\\resourse_imgs\\love.txt");
                //缓冲流
                //默认还是以UTF-8的形式读取，还是会乱码的
                //Reader reader = new InputStreamReader(inputStream) ;
                Reader reader = new InputStreamReader(inputStream,"GBK");
                //包装成缓冲字符输入流管道
                BufferedReader bufferedReader = new BufferedReader(reader)
                ){
            String str_line = null;
            while ((str_line = bufferedReader.readLine()) != null){
                System.out.println(str_line);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

 

 总结一句话就是：要想不乱码，就要使得文件编码、解码一致

如何想要控制写出去的字符使用的编码？【两种方法】

1. 可以把字符以指定编码获取字节后在使用字节输入流写出去："abc一二三".getBytes(编码)
2. 使用字符输出流实现

import java.io.*;

public class InputStreamWriterDemo1 {
    public static void main(String[] args) {
        try(
                //创建字节输出流管道与目的文件接通
                OutputStream outputStream = new FileOutputStream("io-app2\\src\\out2.txt");

                //把原始的字节流包装成字符转换流
                //以默认字符（UTF-8）写入，与直接new FileWriter的性质是一样的
                //Writer writer = new OutputStreamWriter(outputStream);
                Writer writer = new OutputStreamWriter(outputStream,"GBK");  //【低级流，并没有缓冲池】
                //把低级的流包装成高级的缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(writer)
                ){
            bw.write("小");
            bw.write("熊");
            bw.write("饼");
            bw.write("干");
            System.out.println("写入完成");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

out2.txt文档内容：【编码不一致问题导致乱码】

•  对象序列化【把对象数据存入到磁盘文件中去】

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

//对象序列化：使用ObjectOutputStream把内存中的对象存储到磁盘文件中
public class ObjectOutputStreamDemo1 {
    public static void main(String[] args) {
        Student student = new Student("admin","123456");
        try(
                //1、对象序列化：使用对象字节输出流包装字节输出流管道
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io-app2/src/obj.txt"));
                ){
            //直接往文件中写入数据
            oos.writeObject(student);
            System.out.println("序列化完毕");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

 

•  对象反序列化【把存储到磁盘文件中的数据对象恢复成内存中的对象】

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

//使用对象反序列化把磁盘文件中的对象数据恢复成内存中的Java对象数据
public class ObjectInputStreamDemo2 {
    public static void main(String[] args) {
        try(
                //1、创建字节输入流管道包含低级流管道与目标文件接通
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io-app2/src/obj.txt"));
                ){
            Student student = (Student) ois.readObject(); //Object --> 强转 ： Student
            System.out.println(student);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

示例程序运行结果：

 

 条件序列化：

 

 在此对obj.txt进行序列化、反序列化后：

 

 序列化版本号：

 

•  打印流【用着超爽】

import java.io.FileOutputStream;
import java.io.PrintStream;

//使用打印流写数据
public class PrintDemo1 {
    public static void main(String[] args) {
        try(
                //1、打印里对象包装低级的文件字节输出流管道
//              PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt"));
                PrintStream ps = new PrintStream("io-app2/src/ps.txt")
        ){
            ps.println(97);
            ps.println('A');
            ps.println("一串打印流数据");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

ps.txt文档内容：

•  输出重定向（改变输出位置定位到文件）【了解】

 

 

 让我们回到最初的起点，发现out原来是一个静态的（PrintStream）流对象，因为被static修饰了，说明它隶属于System类，在此调用时直接 类名.变量名 ，之后改对象会在静态代码块中被初始化，又因为改对象是个打印流，把它的输出位置定位到了控制台（其实本质上来说，控制台就是一个可以实时打印数据的文件）。当然了，以上这些只是很简陋的分析，真正的过程还是比较复杂的，可参考这篇博客：

https://www.cnblogs.com/zhujiqian/p/13832506.html

 

 

 

 

 

•  Properties【属性集对象】

import java.io.FileWriter;
import java.util.Map;
import java.util.Properties;

//使用Properties把键值对信息存储到属性文件中去
public class PropertiesDemo1 {
    public static void main(String[] args) throws Exception{
        //Map map = new Properties();
        Properties properties = new Properties();
//        properties.put("admin","123456");
//        properties.put("Jack","234567");
//        properties.put("Tom","345678");
        properties.setProperty("admin","123456");  //setProperty内部仍然是put方法
        properties.setProperty("Jack","234567");
        properties.setProperty("Tom","345678");

        properties.store(new FileWriter("io-app2/src/users.properties"),"改参数用于properties文件的注释");
    }
}

users.properties文件中的内容：

 

 

 回复users.properties文件中的数据到Java中去：

import java.io.FileReader;
import java.util.Properties;

//加载Properties文件中的数据到Java开发环境中去
public class PropertiesLoadDemo {
    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
        System.out.println(properties);

        //加载指定的properties文件
        properties.load(new FileReader("io-app2/src/users.properties"));
        System.out.println(properties);

        //通过键取值
        String pwd  =  properties.getProperty("J1ack"); //getProperty方法里边包的还是get【get需要强转】方法
        System.out.println(pwd);
    }
}

 

 

 commons-io框架：

 

 

•  导入commons-io jar包做开发
• 需求：使用commons-io简化io流读写

分析：

1. 在项目中创建一个文件夹: lib;
2. 将commons - io - 2.11.0.jar文件复制到lib文件夹；
3. 在jar文件夹上点右键，选择Add as Library - > 点击OK
4. 在类中导包使用

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.file.Files;
import java.nio.file.Path;

//使用commons-io框架复制文件
public class DommonsIODemo {
    public static void main(String[] args) throws Exception {
        //1、复制文件
//        IOUtils.copy(new FileInputStream("D:\\Intellij_IDEA_install\\resourse_imgs\\natural_view.jpeg"),
//                new FileOutputStream("D:\\Intellij_IDEA_install\\resourse_imgs\\natural_view2.jpeg"));

        //2、拷贝文件到文件夹
//        FileUtils.copyFileToDirectory(new File("D:\\Intellij_IDEA_install\\resourse_imgs\\doraemon.jpeg"),
//                new File("D:\\Intellij_IDEA_install\\resourse_imgs\\emptyFile"));

        //3、文件夹复制到文件夹
        //FileUtils.copyDirectoryToDirectory(new File("D:\\Intellij_IDEA_install\\resourse_imgs\\emptyFile"),
//                new File("D:\\Intellij_IDEA_install\\resourse_imgs\\newEmptyFile"));

        //4、删除文件夹【不经过回收站】
        //FileUtils.deleteDirectory(new File("D:\\Intellij_IDEA_install\\resourse_imgs\\newEmptyFile"));

        //... ...

        //5、JDK1.7自己也做了一行代码可以复制文件的操作 NIO
        //【复制文件夹之后为空文件夹,复制文件没问题】
//        Files.copy(Path.of("D:\\Intellij_IDEA_install\\resourse_imgs\\emptyFile"),
//                Path.of("D:\\Intellij_IDEA_install\\resourse_imgs\\emptyFileAAA"));

//                Files.copy(Path.of("D:\\Intellij_IDEA_install\\resourse_imgs\\natural_view.jpeg"),
//                Path.of("D:\\Intellij_IDEA_install\\resourse_imgs\\natural_viewAAA.jpeg"));

        //【DirectoryNotEmptyException】只能删除空文件夹
//                Files.deleteIfExists(Path.of("D:\\Intellij_IDEA_install\\resourse_imgs\\emptyFileAAA"));
    }
}