稀疏数组java io实现

二维数组转换为稀疏数组：

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

2.根据sum创建稀疏数组，int[sum+1][3]。

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

稀疏数组转换为二维数组：

1.根据稀疏数组第一行的数据创建二维数组。

2.后几行数据赋值给二维数组。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class SparseArray {
    public static void main(String[] args) throws Exception {
        //创建原始二维数组 0无棋子 1黑子 2白子
        int[][] chessArr = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[3][4] = 1;
        System.out.println("原始二维数组：");
        for (int[] row : chessArr){
            for (int item : row){
                System.out.printf("%d\t",item);
            }System.out.println();
        }

        //二维数组转换为稀疏数组：
        //1.遍历原始二维数组，得到有效数据sum。
        int sum = 0;
        for (int i = 0; i < chessArr.length; i++){
            for (int j = 0;j <chessArr[i].length; j++){
                if (chessArr[i][j] != 0){
                    sum ++;
                }
            }
        }
        System.out.println("sum = " + sum);

        //2.根据sum创建稀疏数组，int[sum+1][3]。
        int[][] sparseArr = new int[sum + 1][3];
        //3.将二维数组有效数据存到稀疏数组。
        sparseArr[0][0] = chessArr.length;
        sparseArr[0][1] = chessArr[0].length;
        sparseArr[0][2] = sum;

        int count = 0;
        for (int i = 0; i < chessArr.length; i++){
            for (int j = 0;j <chessArr[i].length; j++){
                if (chessArr[i][j] != 0){
                    count ++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组：");
        for (int[] row : sparseArr){
            for (int item : row){
                System.out.printf("%d\t",item);
            }System.out.println();
        }
        //把稀疏数组放入文件
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter("save.data");
            for (int i = 0; i < sparseArr.length; i ++){
                for (int j = 0; j < sparseArr[i].length; j ++){
                    fileWriter.write(sparseArr[i][j]);
                }
            }
            fileWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null){
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //从文件中读取稀疏数组

        int sparseArr1[][] = new int[sum + 1][3];
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("save.data");
            for (int i = 0;i < sparseArr1.length;i ++){
                for (int j = 0;j < sparseArr1[i].length;j++){
                    sparseArr1[i][j] = fileReader.read();
                }
            }

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

        //稀疏数组恢复为二维数组：
        //1.根据稀疏数组第一行的数据创建二维数组。
        System.out.println("还原为二维数组：");
        int[][] chessArr1 = new int[sparseArr1[0][0]][sparseArr1[0][1]];
        //2.后几行数据赋值给二维数组。
       for (int i = 1; i < sparseArr.length; i ++){
           chessArr1[sparseArr1[i][0]][sparseArr1[i][1]] = sparseArr1[i][2];
       }
        for (int[] row : chessArr1){
            for (int item : row){
                System.out.printf("%d\t",item);
            }System.out.println();
        }
    }

}

run：