将二维数组转换成稀疏数组，并写入到文件中，读取文件中的稀疏数组，将其恢复到原始的二维数组

稀疏数组

例如二维数组中有很多0或者同一值，如果将这些数据元素全部记录保存的话，会浪费存储空间，因为记录了许多无意义的值。所以需要利用稀疏数组对二维数组进行压缩。
方法：
1.记录二维数组的行、列数及非0值的个数
2.将二维数组中的非0值所在的行、列数及其值记录下来
3.构建一个小规模的数组

例如：

代码如下：
（1）main()

public static void main(String[] args) {
        int[][] arr = new int[5][5];
        arr[0][0] = 1;
        arr[0][1] = 0;
        arr[0][2] = 0;
        arr[0][3] = 0;
        arr[0][4] = 0;
        arr[1][0] = 0;
        arr[1][1] = 1;
        arr[1][2] = 0;
        arr[1][3] = 0;
        arr[1][4] = 0;
        arr[2][0] = 0;
        arr[2][0] = 0;
        arr[2][1] = 0;
        arr[2][2] = 1;
        arr[2][3] = 0;
        arr[2][4] = 0;
        arr[3][0] = 0;
        arr[3][1] = 0;
        arr[3][2] = 0;
        arr[3][3] = 0;
        arr[3][4] = 0;
        arr[4][0] = 0;
        arr[4][1] = 0;
        arr[4][2] = 0;
        arr[4][3] = 0;
        arr[4][4] = 0;
        //得到有效数据个数
        int count = getValidNum(arr);
        //创建稀疏数组：int[有效数据的个数+1][3]
        //1.根据原始二维数组的 行数列数 非0个数
        //2.每个有效数据在原始数组中的 行列数，及其数值
        //得到原始数组中的有效数据个数+1=稀疏数组的行数
        int[][] sparseArr = getSparseArr(arr, count);
        //将稀疏数组写入文件中
        writeToFile(sparseArr);
        //读取文件中的稀疏数组
        int[][] sparseArray= getSparseArrFromFile();

        for(int i=0;i<sparseArray.length;i++){
            for(int j=0;j<3;j++){
                System.out.print(sparseArray[i][j]+" ");
            }
            System.out.println();
        }

        //创建二维数组，行列数分别为sparseArr[0][0]]，[sparseArr[0][1]
        //int[][] originalArray=new int[sparseArray[0][0]][sparseArray[0i][1]];
        int[][] originalArray=sparseArrayToOriginalArray(sparseArray);
        for(int i=0;i<originalArray.length;i++){
            for(int j=0;j<originalArray[i].length;j++){
                System.out.print(originalArray[i][j]+"\t");
            }
            System.out.println();
        }
    }

（2）getValidNum()
遍历二维数组，统计得到有效数据的个数

    public static int getValidNum(int[][] arr) {
        int count = 0;     //统计二维数组中的非0有效数据的个数
        //遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    count++;
                }
            }
        }
        return count;
    }

(3)getSparseArr()
得到稀疏数组sparseArr

    public static int[][] getSparseArr(int[][] arr, int count) {
        //创建稀疏数组 int[有效数据的个数+1][3]
        int[][] sparseArr = new int[count + 1][3];
        sparseArr[0][0] = arr.length;
        sparseArr[0][1] = arr[0].length;
        sparseArr[0][2] = count;
        //flag跟count作用一致，也是用来统计非0数据个数
        int flag = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    //从第二行开始记录 非0数据在原始数组中的行列数 及值
                    flag++;
                    sparseArr[flag][0] = i;
                    sparseArr[flag][1] = j;
                    sparseArr[flag][2] = arr[i][j];
                }
            }
        }
        return sparseArr;
    }

(4)writeToFile()
将稀疏数组写入文件sparseArr.txt

    public static void writeToFile(int[][] sparseArr){
        //将数据写入文件
        //FileWriter无法将int数据直接写入文件，可以 转成String再写入
        FileWriter fw=null;
        try {
            fw=new FileWriter("src\\com\\dataStructures\\sparseArr.txt");
            //遍历稀疏数组 写入文件
            //注意要转换数据的类型
            for (int i = 0; i < sparseArr.length; i++) {
                for (int j = 0; j < sparseArr[i].length; j++) {
                    fw.write(Integer.toString(sparseArr[i][j]));
                    fw.write(" ");
                }
                fw.write("\n");
            }
            fw.flush();
            System.out.println("写入完毕");
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

(5)getSparseArrFromFile()
读取文件中的稀疏数组

    public static int[][] getSparseArrFromFile(){
        //读取文件中的稀疏数组
        FileReader fr=null;
        BufferedReader br=null;
        try {
            fr=new FileReader("src\\com\\dataStructures\\sparseArr.txt");
            //缓冲字符流
            //这里的 fr表示节点流，br表示包装流
            br=new BufferedReader(fr);
            String line;
            String[] arrStr=null;     //将文件中的每一行 写入字符串数组中
            int flag=0;
             //创建int[x][3]的二维数组，行数待定，尽量选大一些，防止出异常
            int[][] sparseArray=new int[5][3]; 
            while((line=br.readLine())!=null){
                arrStr=line.split(" ");
                //遍历字符串数组，得到稀疏数组的各个元素
                for(int i=0;i<arrStr.length;i++){
                    sparseArray[flag][i]=Integer.parseInt(arrStr[i]);
                }
                flag++;       
            }
            //通过获取到的flag值来确定真实的 稀疏数组的行数
            //创建a数组 获取稀疏数组中的数据
            int[][] a=new int[flag][3];
            for(int i=0;i<flag;i++){
                for(int j=0;j<3;j++){
                    a[i][j]=sparseArray[i][j];
                }
            }
            return a;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //只需关闭最外层的 包装流即可，不需要再fr.close()了
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
       return null;
    }          

(6)sparseArrayToOriginalArray()
将稀疏数组还原成原始的二维数组

    public static int[][] sparseArrayToOriginalArray(int[][] sparseArray){
        int[][] originalArray=new int[sparseArray[0][0]][sparseArray[0][1]];
        //遍历稀疏数组，将其非0值数据写入到原始数组中
        for(int i=0;i<sparseArray.length-1;i++){
            originalArray[sparseArray[i+1][0]][sparseArray[i+1][1]]=sparseArray[i+1][2];
        }
        return originalArray;
    }