利用 Java io 包进行文件读写操作

2017-10-30

前些天面试的时候考了两道题，都是有关 Java 基础的：

• 利用 Java io 包进行读写文件；
• 使用 JDBC 获取数据。

很可惜当时记不起来这些基础知识，所以很有必要整理一下，巩固一下这方面的知识。

在这篇总结里，我将通过代码，文字解释两部分来总结 io 包的读写文件操作。

---

场景

例如在桌面上有一份 1.txt 文件，里面是一行以半角逗号分隔的乱序数字。请编写 Java 程序读取该文件，并降序排序，写到 2.txt 文件中（若没有就新建）。限用 io 包。

考察知识点

• 读取文件
• 字符串与整型数组之间的转换
• 排序算法
• 写文件

代码示例

我也将代码托管在码云平台，可以前往参考：https://gitee.com/jinglun404/io-demo

import java.io.*;

public class Main {

    public static void main(String[] args) {
        String filePath = "C:\\Users\\ASUSS\\Desktop\\1.txt";

        readFile(filePath);
    }

    // 读取文件方法
    public static void readFile(String filePath) {
        try {
            String encoding = "UTF-8";
            // 1.获得File对象
            File file = new File(filePath);

            if (file.isFile() && file.exists()) { // 判断文件是否存在
                // 2.File对象->FileInputStream对象->InputStreamReader对象
                InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
                System.out.println("read:" + read); //read:java.io.InputStreamReader@14ae5a5

                // 3.通过InputStreamReader对象获得BufferedReader对象
                BufferedReader bufferedReader = new BufferedReader(read);
                System.out.println("bufferedReader:" + bufferedReader); //bufferedReader:java.io.BufferedReader@7f31245a

                // 4.通过BufferedReader对象将文件内容以字符串形式读出
                String lineText = null;
                while ((lineText = bufferedReader.readLine()) != null) {
                    System.out.println("lineText:" + lineText); //lineText:1,1,4,5,23,12,13,35,345,34,67,5,3,90

                    // 将读取的字符串根据“，”分割成字符串数组
                    String[] stringNums = lineText.split(",");

                    // 将字符串数组转换成整型数组，用于排序
                    int[] intNums = new int[stringNums.length];
                    for (int i = 0; i < stringNums.length; i++) {
                        intNums[i] = new Integer(stringNums[i]);
                    }

                    // 调用排序方法
                    mySort(intNums);

                    // 将整型数组转换成字符串，用于写入文件
                    String s = "";
                    for (int i = 0; i < intNums.length; i++) {
                        s += intNums[i] + ",";
                    }
                    s = s.substring(0, s.length()-1);// 去掉最后一个“,”

                    // 调用写文件方法
                    writeFile(s);
                }
                read.close();

            } else {
                System.out.println("找不到指定文件！");
            }
        } catch (Exception e) {
            System.out.println("读取文件出错！");
            e.printStackTrace();
        }
    }

    // 写入文件方法
    private static void writeFile(String s) {
        String writeFile = "C:\\Users\\ASUSS\\Desktop\\2.txt";

        // 1.获得File对象
        File newFile = new File(writeFile);

        try {
            if (!newFile.exists()) {
                // 若文件不存在，则新建文件
                newFile.createNewFile();
            }

            // 2.通过File对象获得FileOutputStream对象
            FileOutputStream out = new FileOutputStream(newFile, true);
            StringBuffer sb = new StringBuffer();
            sb.append(s);

            // 3.通过FileOutputStream进行写操作
            out.write(s.toString().getBytes("UTF-8"));
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 冒泡排序，降序输出
    private static void mySort(int[] intNums) {
        int temp = 0;
        for (int i = 0; i < intNums.length; i++) {
            for (int j = 0; j < intNums.length - i - 1; j++) {
                if (intNums[j] < intNums[j + 1]) {
                    temp = intNums[j];
                    intNums[j] = intNums[j + 1];
                    intNums[j + 1] = temp;
                }
            }
        }
    }
}

说明

读取文件

利用 Java 的 io 包读取文件内容，分为几个步骤：

1. 传入文件路径生成 File 对象实例
2. 通过 File 实例生成 FileInputStream 对象实例
3. 通过 FileInputStream 对象实例生成 InputStreamReader 对象实例
4. 通过 InputStreamReader 对象实例生成 BufferedReader 对象实例
5. 通过 BufferedReader 对象实例的 .readLine() 方法读取文件的一行数据

一般步骤如上，但为何要这样做呢？我的理解如下：

1. Java 的文件操作都是基于 File 对象的，因此读取文件操作的第一步肯定是获取一个 FIle 对象实例，那么获取怎样的实例呢？由此很容易联想到需要获取我们进行读取的文件的 File 实例。所以这里便需要传入文件路径参数，来构造出一个 File 实例。
2. 获取了 File 的实例，我们的 Java 程序便与文件取得了联系，接下来需要将文件读入到内存中，方便我们的 Java 程序进行后续操作。
3. 通过生成 FileInputStream 对象实例，我们将文件内容以字节形式写入到内存。
4. 但我们读不懂字节内容，因此不能直接输出存到内存中的字节内容。需要进行继续转换。
5. 通过生成 InputStreamReader 对象实例，我们读取了内存中的字节内容，然后进一步生成 BufferedReader 对象实例，将字节内容放在缓存区，加快操作的速度。
6. 最后，利用 BufferedReader 的 .readLine() 方法，将字节转换成我们能读懂的字符串信息，进行输出。

写入文件

利用 Java io 包进行写入文件，操作思路跟读取文件类似，甚至简单些，例如：

1. 获取 File 对象实例
2. 通过 File 实例获取 FileOutputStream 对象实例
3. 利用 FileOutputStream 的 .write() 方法将字节数据写入文件

当然这只是大概思路。具体实现过程可以参考我的代码逻辑。

排序逻辑

对数字进行排序，实现的方法很多，我这里使用了常见的冒泡排序，具体不展开讲了，网上也有很多资料。也可以参考我代码的逻辑。

 

参考网站

http://www.cnblogs.com/manongxiaojiang/archive/2012/10/13/2722068.html
https://segmentfault.com/q/1010000000359840
https://www.ezloo.com/2008/03/jave_file_reader_writer.html