如何将一个二维数组转化为稀疏数组，并且将稀疏数组存入磁盘，从磁盘取出稀疏数组。

package CSDN;

import java.io.*;
import java.util.Arrays;

/**
 * @author Babulakaka
 * @create 2021-06-10 19:14
 */
public class SparseArrayTest {
    public static void main(String[] args) {
        //首先定义一个二维数组
        int[][] arr = new int[11][11];
        arr[4][3] = 1;
        arr[7][10] = 1;
        arr[6][8] = 2;
        arr[5][6] = 2;
        int sum = 0;//原数组有效数的个数（非零元素）
        //显示原数组
        System.out.println("原数组为：");
        for (int[] a : arr) {
            for (int data : a) {
                if (data != 0) {
                    sum++;
                }
                System.out.print(data + " ");
            }
            System.out.println();
        }
        //定义稀疏数组 , 稀疏数组的行数是原数组有效数字的个数+1，列数为3.
        int[][] sparseArr = new int[sum + 1][3];
        //稀疏数组sparseArr[0][0]表示原数组总行数 sparseArr[0][1]表示原数组总列数
        // sparseArr[0][2] 表示有效数字的个数
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        //为稀疏数组赋值,稀疏数字除了第一行外，第一列表示原数组有效数字所在的行，第二列表示原数组有效数字所在的列
        //第三列表示有效数字
        //给稀疏数组赋值
        int count = 1;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arr[i][j];
                    count++;
                }
            }
        }
        //输出稀疏数组
        System.out.println("转换后的稀疏数组为：");
        for (int[] a : sparseArr) {
            for (int data : a) {
                System.out.print(data + " ");
            }
            System.out.println();
        }

        //再将稀疏数组转回原来的数组
        //根据稀疏数组的第一行的数据创建数组
        int[][] arr1 = new int[sparseArr[0][0]][sparseArr[0][1]];
        //再将稀疏数组的有效数据塞入arr1
        int row = 0;//行
        int col = 0;//列
        int val = 0;//值
        for (int i = 1; i < sparseArr.length; i++) {
            for (int j = 0; j < sparseArr[i].length; j++) {
                switch (j) {
                    case 0:
                        row = sparseArr[i][j];
                        break;
                    case 1:
                        col = sparseArr[i][j];
                        break;
                    case 2:
                        val = sparseArr[i][j];
                        break;
                }

            }
            arr1[row][col]=val;
        }
        //输出被稀疏数组转换回来的数组
        System.out.println("恢复后的数组为：");
        for (int[] a : arr1) {
            for (int data : a) {
                System.out.print(data + " ");
            }
            System.out.println();
        }


        //将稀疏数组存入磁盘中 : 运用到I\O流的内容 我们使用FileWriter字符输出流
        FileWriter fw=null;
        try {
             fw= new FileWriter(new File("src\\sparseArr"));
            for(int i = 0;i<sparseArr.length;i++){
                fw.write(sparseArr[i][0]+" ");
                fw.write(sparseArr[i][1]+" ");
                fw.write(sparseArr[i][2]+" \n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("已将稀疏数组存入磁盘中~~");

        //先要将磁盘中的数组取出 我们利用的是BufferedReader字符输入流
        BufferedReader br = null;
        try {
             br = new BufferedReader(new FileReader("src\\sparseArr"));
            //我们把读出的数据存入sparseArr1
            int [][] sparseArr1;
            int temp=0;//用来初始化稀疏数组大小的
            while(br.readLine()!=null){
                temp++;
            }
            sparseArr1=new int[temp][3];

            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //读完之后关闭流，避免以后再读的时候读的是空串

            //重新打开流，从文件头开始读,把稀疏数组的有效数字读入
            br=new BufferedReader(new FileReader("src\\sparseArr"));
            String str;
            int i=0;
            int j=0;
            System.out.println("从磁盘读出的稀疏数组为：");
            while((str=br.readLine())!=null){
                String[] s = str.split(" ");//将读到的字符按照空格隔开，得到一个字符串数组
                for(String s1:s){//遍历该数组
                    sparseArr1[i][j]=Integer.parseInt(s1);
                    //顺便输出从磁盘读出的数组
                    System.out.print(sparseArr1[i][j]+" ");
                    j++;
                }
                System.out.println();
                j=0;
                i++;
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}