前言

大家好，我是小郭，今天我们一起来回顾一下，IO是我们日常开发中经常使用到的技能，但是一不小心我们就会踩坑，今天梳理了我在工作中遇到的一些问题。

第一坑：文件读写需要确保字符编码一致

场景：我们先将编码格式为GBK的值写入 outputStream 中，然后再使用 UTF-8 的格式将他输出。

private void ByteArrayOutputStreamTest(){
    byte[] bytes;
    try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()){

        byteArrayOutputStream.write("you ".getBytes());
        byteArrayOutputStream.write("see ".getBytes());
        byteArrayOutputStream.write("see 你 ".getBytes()));

        bytes = byteArrayOutputStream.toByteArray();

        System.out.println(new String(bytes, Charset.forName("GBK")));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

输出结果：

话不多说，我们看源码，发现它是有一个默认值的，而且默认的格式为 UTF-8

public static Charset defaultCharset() {
    if (defaultCharset == null) {
        synchronized (Charset.class) {
            String csn = AccessController.doPrivileged(
                new GetPropertyAction("file.encoding"));
            Charset cs = lookup(csn);
            if (cs != null)
                defaultCharset = cs;
            else
                defaultCharset = forName("UTF-8");
        }
    }
    return defaultCharset;
}

接下来我们需要做什么？

那必须是将它们的字符编码都保持一致，再看下输出结果

第二坑：Files类调用readAllLines，会造成OOM

直接看源码，就知道为什么，一次将所有文件中的内容都读取出，要是文件内容过大就会撑爆内存

public static List<String> readAllLines(Path path, Charset cs) throws IOException {
    //使用BufferedReader读取文件
    try (BufferedReader reader = newBufferedReader(path, cs)) {
        //声明一个List
        List<String> result = new ArrayList<>();
        //将读出的值，塞入list
        for (;;) {
            String line = reader.readLine();
            if (line == null)
                break;
            result.add(line);
        }
        return result;
    }
}

解决方案：
可以调用limit来限制需要读出的数据

Files.lines(Paths.get("read1.txt")).limit(2000);

第三坑：使用FIles类静态方法进行文件操作注意释放文件句柄

private static void wrong() {
    //ps aux | grep CommonMistakesApplication
    //lsof -p 63937
    LongAdder longAdder = new LongAdder();
    IntStream.rangeClosed(1, 1000000).forEach(i -> {
        try {
            Files.lines(Paths.get("demo.txt")).forEach(line -> longAdder.increment());
        } catch (IOException e) {
            e.printStackTrace();
        }
    });
    log.info("total : {}", longAdder.longValue());
}

输出结果：

为什么会造成这个问题呢?

主要是因为lines方法返回的是stream，句柄没有释放。
利用try-with-resources来解决这个问题，在结束的时候自动去关闭句柄

第四坑：注意读写文件要考虑设置缓冲区

在进行文件操作的时候，很少时候字节是使用字节流来读写文件，主要是字节流慢。
更多时候利用缓存区，进行批量的操作，减少传输的消耗，提高速度。

//操作字节流
private static void perByteOperation() throws IOException {
    Files.deleteIfExists(Paths.get("dest.txt"));

    try (FileInputStream fileInputStream = new FileInputStream("src.txt");
         FileOutputStream fileOutputStream = new FileOutputStream("dest.txt")) {
        int i;
        while ((i = fileInputStream.read()) != -1) {
            fileOutputStream.write(i);
        }
    }
}

//添加缓冲区
private static void bufferOperationWith100Buffer() throws IOException {
    Files.deleteIfExists(Paths.get("dest.txt"));

    try (FileInputStream fileInputStream = new FileInputStream("src.txt");
         FileOutputStream fileOutputStream = new FileOutputStream("dest.txt")) {
        byte[] buffer = new byte[100];
        int len = 0;
        while ((len = fileInputStream.read(buffer)) != -1) {
            fileOutputStream.write(buffer, 0, len);
        }
    }
}
//操作缓冲字节流
private static void bufferedStreamBufferOperation() throws IOException {
    Files.deleteIfExists(Paths.get("dest.txt"));

    try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("src.txt"));
         BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("dest.txt"))) {
        byte[] buffer = new byte[8192];
        int len = 0;
        while ((len = bufferedInputStream.read(buffer)) != -1) {
            bufferedOutputStream.write(buffer, 0, len);
        }
    }
}

总结

在操作IO流的时候，需要在涉及编码、内存的时候特别注意一下