JAVA 将二维数组转化为稀疏数组保存到文件,再读取文件转化为二维数组

本文链接：https://blog.csdn.net/Sundy_sc/article/details/107542758

本文介绍了如何使用JAVA将含有大量0的二维数组转化为稀疏数组，然后将其保存到文件中。之后从文件读取数据，再将稀疏数组还原为二维数组。详细步骤包括遍历二维数组、创建稀疏数组、文件读写操作等，最后验证转换后的二维数组与原始数组一致。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

场景：将五子棋盘（二维数组）中，有效的数据保存到稀疏数组中并将稀疏数组保存到本地文件。然后将读取文件中的数据，并将数据转换成二维数组。

因为五子棋该二维数组中有很多值是默认值 0, 因此记录了很多没有意义的数据.所以这里使用到稀疏数组，保存有效数据。

解题思路：

二维数组转稀疏数组并存入本地文件：

1. 遍历原始的二维数组，得到有效数据的个数 sum

2. 根据sum 就可以创建稀疏数组 sparseArr int[sum + 1] [3]

3. 将二维数组的有效数据数据存入到稀疏数组

4.使用字符输出缓冲流将稀疏数组写入文件中

读取文件，转稀疏数组转原始的二维数组：

1.使用字符输入缓冲流将本地文件中的字符串存入List集合中

2.获取List集合中的每个元素，并根据\t切割，存入字符数组中

3.遍历字符数组，并将数组中的元素分别放入稀疏数组

4. 读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]

5. 再读取稀疏数组后几行的数据，并赋给原始的二维数组即可.

代码实现

1）定义一个 11*11的二维数组，并为部分元素赋值，并输出二维数组

       int [][] chessArr = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[6][5] = 1;

        //输出二维数组
        for(int[] chesses:chessArr){
            for(int chess:chesses){
                System.out.print("\t"+chess);
            }
            System.out.println();
        }

输出结果：

   0   0   0   0   0   0   0   0   0   0   0
   0   0   1   0   0   0   0   0   0   0   0
   0   0   0   2   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   1   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0

2）获取二维数组中有效的数据个数

       int sum=0;
        for(int[] chesses:chessArr){
            for(int chess:chesses){
                if(chess != 0){
                    sum=sum+1;
                }
            }
        }
        System.out.println("sum="+sum);

这里输出结果 sum=3

3）定义稀疏数组并输出。这里说明一下，稀疏数组固定列数为3列（第1列为行，第2列为列，第3列为值）。稀疏数组的第一行的三个值分别存储的是二维数组行数、列数、有效元素个数。所以定义数组时，行为sum+1

        int[][] sparseArr = new int[sum+1][3];
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        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=count+1;
                   sparseArr[count][0] = i ;
                   sparseArr[count][1] = j ;
                   sparseArr[count][2] = chessArr[i][j] ;
               }
           }
       }

       //遍历稀疏数组
        for(int i=0;i<sparseArr.length;i++){
            System.out.print("\t"+sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]+"\n");
        }

输出结果：

   11   11   3
   1   2   1
   2   3   2
   6   5   1

4）将上述稀疏数组写入 sparse.txt文件中

 BufferedWriter writer = new BufferedWriter(new FileWriter("./sparse.txt"));
        for(int i=0;i<sparseArr.length;i++){
            writer.write("\t"+sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]+"\n");
            writer.flush();
        }
        writer.close();

查看工程下自动生成sparse.txt文件，内容如下

5）读取 sparse.txt文件中的内容，并将读到的内容添加到List集合中。元素的个数即为稀疏数组的行数。

然后遍历List，将List中的每个元素用指定分隔符分隔，并存入String数组中。

最后将String数组中的每个元素分别写入到稀疏数组中。

 //将 sparse.txt中的内容，读取到 稀疏数组
        BufferedReader reader = new BufferedReader(new FileReader("./sparse.txt"));
        List<String> list = new ArrayList<String>();
        String line = null;
        while((line = reader.readLine()) != null) {
                list.add(line.trim());
        }
        reader.close();

        System.out.println("遍历list------------------");
        int [][] sparseArr1 = new int[list.size()][3];
        for(int k=0;k<list.size();k++){
            System.out.println(list.get(k));
            String[] arr = list.get(k).trim().split("\t");
            sparseArr1[k][0] = Integer.parseInt(arr[0]);
            sparseArr1[k][1] = Integer.parseInt(arr[1]);
            sparseArr1[k][2] = Integer.parseInt(arr[2]);
        }
  
        System.out.println("遍历稀疏数组------------------");
        for(int i=0;i<sparseArr1.length;i++){
            System.out.print("\t"+sparseArr1[i][0]+"\t"+sparseArr1[i][1]+"\t"+sparseArr1[i][2]+"\n");
        }

输出结果：

遍历list------------------
11   11   3
1   2   1
2   3   2
6   5   1
遍历稀疏数组------------------
   11   11   3
   1   2   1
   2   3   2
   6   5   1

6）定义11*11的二维数组，并将稀疏数组中的值分别回填到对应二维数组中，并遍历二维数组

       //将稀疏数组转换成11*11二维数组
        int [][] chessArr2 = new int[11][11];
        for(int i=1;i<sparseArr1.length;i++){
             chessArr2[sparseArr1[i][0]][sparseArr1[i][1]] = sparseArr1[i][2];
        }


        //输出二维数组
        System.out.println("遍历二维数组------------------");
        for(int[] chesses:chessArr2){
            for(int chess:chesses){
                System.out.print("\t"+chess);
            }
            System.out.println();
        }

输出结果：

ok，JAVA 将二维数组转化为稀疏数组保存到文件,再读取文件转化为二维数组的全部过程完成。可以看到最后输出的结果和最初的二维数组一致。