数据结构 -- 稀疏数组本地读写版代码实现

最近开始肝数据结构了，老韩布置了作业让把代码改成可以写入和读取本地文件的版本，刚好前几天才学完JavaSE，想着soeasy，结果各种报错乱码写不全，又滚回去复习了一遍…，在网上也搜了下相关的解决方法，整合了下，写了个自己的版本，都差不多。

package demo01;
import org.junit.jupiter.api.Test;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class SparseArrWithFileTest {

    @Test
    public void test1() throws IOException {


        // 一、 将原二维数组转换为稀疏数组

        // 1. 创建二维数组, 条件为11行11列
        int[][] chessArr1 = new int[11][11];
        // 赋值: 0: 代表空, 1: 代表白棋子 2: 代码黑棋子
        chessArr1[0][6] = 1;
        chessArr1[1][3] = 1;
        chessArr1[4][7] = 1;
        chessArr1[3][5] = 2;
        chessArr1[8][9] = 2;

        // 2. 获取二维数组有效数(非零)的个数, 并遍历输出
        int totalNum = 0;
        for (int[] row : chessArr1) {
            for (int item : row) {
                if (item != 0) totalNum++;
                System.out.print(item + "\t");
            }
            System.out.println();
        }

        // 3. 创建稀疏数组
        // 稀疏数组的行数为: totalNum + 1, 第一行用于保存原二维数组的信息
        // 稀疏数组的列数为: 3, 第一列保存行信息, 第二列保存列信息, 第三列保存值信息
        int[][] sparseArr = new int[totalNum + 1][3];
        // 将原二位数组的信息保存在第一行
        sparseArr[0][0] = chessArr1.length;      // 保存原二维数组的行数
        sparseArr[0][1] = chessArr1[0].length;   // 保存原二维数组的列数
        sparseArr[0][2] = totalNum;              // 保存有效数的个数

        // 4. 将有效数存入稀疏数组中
        int count = 0;  // 用于纪录稀疏数组的行数
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {  // 找到不为0的有效数
                    count++;  // 从稀疏数组第二行(下标为1)开始存储
                    sparseArr[count][0] = i;  // 保存有效数的行下标
                    sparseArr[count][1] = j;  // 保存有效数的列下标
                    sparseArr[count][2] = chessArr1[i][j];  // 保存有效数
                }
                if (count == totalNum) break;
            }
            if (count == totalNum) break;
        }

        // 输出
        printArr(sparseArr);

        // 5. 将稀疏数组的信息写入到本地文件中
        String path = "data.txt";
        fileWrite(path,sparseArr);


        // 二、 将稀疏数组转为二维数组：

        // 1. 从本地读取存放的稀疏数组
        int[][] newSparseArr = fileRead(path);
        printArr(newSparseArr);

        // 2. 创建新的二维数组
        // 行数为稀疏数组下标(0,0)的值, 即保存的原二维数组的行数
        // 列数为稀疏数组下标(0,1)的值, 即保存的原二维数组的列数
        int[][] chessArr2 = new int[newSparseArr[0][0]][newSparseArr[0][1]];

        // 3. 通过稀疏数组中前两列的值找到有效数对应的下标, 并将第三列的值存放在该位置中
        for(int i = 1; i < newSparseArr.length;i++){ // 从第二行(行下标为1)开始遍历
            chessArr2[newSparseArr[i][0]][newSparseArr[i][1]] = newSparseArr[i][2];
        }
        printArr(chessArr2);
    }

    /**
     * 打印二维数组
     * @param arr 需要打印的二维数组
     */
    public void printArr(int[][] arr){
        for(int[] row: arr){
            for(int item : row){
                System.out.print(item + "\t");
            }
            System.out.println();
        }
    }


    /**
     *  从本地文件读取稀疏数组
     * @param filePath 文件路径
     * @return 返回通过读取数据创建的新稀疏数组
     * @throws IOException
     */
    public int[][] fileRead(String filePath) throws IOException {
        // 获取文件每一行组成的集合
        List<String> list = Files.readAllLines(Paths.get(filePath));
        // 通过list的长度, 即行数创建新的稀疏数组
        int[][] newSparseArr = new int[list.size()][3];
        // 遍历赋值
        for(int i = 0; i < list.size();i++){
            // 将list中每一行的字符串, 以"\t"分割为字符串数组
            String[] split = list.get(i).split("\t");
            for(int j = 0; j < split.length;j++){
                // 将数组中的每个元素转换为Integer类型, 并赋值给新的稀疏数组
                newSparseArr[i][j] = Integer.parseInt(split[j]);
            }
        }
        // 返回新创建的稀疏数组
        return newSparseArr;
    }


    /**
     *  将稀疏数组写入本地文件中，把数组中每个元素作为字符串添加至本地文件
     * @param filePath
     * @param sparseArr 稀疏数组
     */
    public void fileWrite(String filePath ,int sparseArr[][])  {
        FileWriter fw = null;
        try {
            // 创建指定路径的File类对象
            File file = new File(filePath);
            // 创建字符节点流
            fw = new FileWriter(file);
            // 遍历
            for(int[] row:sparseArr){
                for(int item:row){
                    fw.write(item + "\t"); // 将每个数组中每个元素作为字符串添加至本地文件
                }
                // 换行
                fw.write("\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fw != null){
                try {
                    // 关闭流资源, 因为需要关闭资源,所以不建议throws异常, 而是直接在本方法内处理掉异常
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}