二维数组转稀疏数组小练习（涵盖将数据存入磁盘）

四个步骤

1、将原始二维数组转为稀疏数组

2、将数据存入磁盘

3、从磁盘读取数据，为稀疏数组

4、再将读取到的稀疏数组转为原始二维数组

代码实现：

        代码主体（重构后的）

import java.io.*;

public class Array{

    public static void main(String[] args) throws IOException {

        // 自定义一个文件名
        String fileName = "./arr.data";
        
        // 假设一个原始二维数组数据
        int[][] chessArr = new int[11][11];
        chessArr[1][2]=1;
        chessArr[2][3]=2;
        chessArr[2][2]=1;
        chessArr[3][2]=2;
        System.out.println("原始棋盘数据：");
        printArray(chessArr);
        

        // 转为稀疏数组
        int[][] sparseArr = chessArrToSparesArr(chessArr);
        System.out.println("-----------------------");
        System.out.println("原始数据转为稀疏数组后:");
        printArray(sparseArr);


        //存入磁盘
        File file = saveFile(sparseArr,fileName);

        // 从磁盘中读取数据
        int[][] sparseArray = getSparseArrayFromFile(file);

        System.out.println("-----------------------");
        System.out.println("文件中读取稀疏数组:");
        printArray(sparseArray);
        

        // 转为原始数组
        int[][] chessArr2 = sparseArrToChessArr(sparseArray);
        System.out.println("-----------------------");
        System.out.println("文件中读取稀疏数组后转为原始数据:");
        printArray(chessArr2);

    }

        原始数据长这样:

        

      二维数组转稀疏数组（ chessArrToSparesArr(int[][] arr)函数）

private int[][] chessArrToSparesArr(int[][] chessArr) {
        // 稀疏数组是固定的3列
        // 要确定原始数据有多少非零元素

        int sum = 0;
        for (int[] ints : chessArr) {

            for (int j = 0; j < ints.length; j++) {

                if (ints[j] != 0) {
                    sum++;
                }
            }

        }
        
        // 初始化，并赋值第一行数据
        int[][] sparseArr=new int[sum+1][3];

        sparseArr[0][0]= chessArr.length;

        sparseArr[0][1]= chessArr.length; // 这里应该灵活改变（应该是上面那个ints.length）

        sparseArr[0][2]= sum;


        // 为剩余的行列赋值
        int count=0;

        for (int i = 0; i < chessArr.length; i++) {

            for (int j = 0; j < chessArr.length; j++) {

                if(chessArr[i][j] != 0){

                    count++;

                    sparseArr[count][0]=i;

                    sparseArr[count][1]=j;

                    sparseArr[count][2]=chessArr[i][j];

                }

            }

        }

        return sparseArr;

    }

转换之后长这样：

        

将数据存入磁盘（saveFile(int[][] arr,String fileName)函数）

private File saveFile(int[][] sparseArr, String fileName) throws IOException {

        // 思路就是直接将数组的一行，作为一整个字符串写入，比较方便

        File file = new File(fileName);

        FileWriter fileWriter = null;

        try {

            fileWriter = new FileWriter(file);

            for (int[] ints : sparseArr) {

                // 这里用什么字符做间隔符，读取的时候也一定要同样的
                fileWriter.write(ints[0] + "\t" + ints[1] + "\t" + ints[2]);

                fileWriter.write(System.getProperty("line.separator"));
                //获取当前系统所需的换行符 \r、\n、\r\n

            }

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

        fileWriter.close();

        return file;

    }

如果想看存入文件之后长什么样，fileName后缀可以改为".txt"的格式

        

 数据回溯--从磁盘文件中读取数据（getSparseArrFromFile(String file)函数）

private int[][] getSparseArrayFromFile(File file) throws IOException {

        FileReader fileReader = new FileReader(file);

        //创建字符读取缓冲流

        BufferedReader bufferedReader = new BufferedReader(fileReader);

        int[][] sparseArray = null;

        String readLine = null ;  // 用来储存读取的一行字符串

        int count1=0; //

        while ((readLine = bufferedReader.readLine()) != null){

            String[] tempStr = readLine.split("\t");
           //  根据前面自己定义的正则表达式的匹配拆分此字符串。

            //判断数组是否创建，未创建则创建

            if(sparseArray == null){

                sparseArray = new int[Integer.parseInt(tempStr[2])+1][3];

            }

            sparseArray[count1][0] = Integer.parseInt(tempStr[0]);

            sparseArray[count1][1] = Integer.parseInt(tempStr[1]);

            sparseArray[count1][2] = Integer.parseInt(tempStr[2]);

            count1++;

        }

        fileReader.close();

        return sparseArray;

    }

数据还长原来那样，就不放图了

最后一步，重新将稀疏数组转为原始的二维数组--

sparseArrToChessArr(int[][] sparseArr)函数

private int[][] sparseArrToChessArr(int[][] sparseArray) {
        // 稀疏数组第一行就记录了 原始数组有几行几列，可以直接初始化

        int[][] chessArr=new int[sparseArray[0][0]][sparseArray[0][1]];
            
        // 遍历赋值
        for (int i = 1; i < sparseArray.length; i++) {

            chessArr[sparseArray[i][0]][sparseArray[i][1]]=sparseArray[i][2];

        }

        return chessArr;

    }

结束---

prinlnArr(int[][] arr)函数：

private void printArray(int[][] array){
        if(array == null){
            return;
        }
        for (int[] row : array) {
            System.out.println();
            for (int j : row) {
                System.out.printf("%d\t", j);
            }
            System.out.println();
        }
    }

二维数组转稀疏数组的好处就是，可以去重大量重复的数值，节省空间，如果不同的值多，就不建议了，这也只是一个小demo

要明白稀疏数组的特征

        第一行记录了什么东西，能有多少行

              ​​​​​​

 注意：数组下标是从0开始