稀疏数组

有时候，我们写一个游戏，比如说棋盘、俄罗斯方块、扫雷等，需要用二维数组来保存每个位置，记录每个位置不同的标记，因为有棋子或雷的地方肯定需要在数组中体现，比如说，下面这个数组，就代表着一个棋盘，为0的地方没有棋子，为1的地方存在黑色棋子，为2的地方存在白色棋子

0，0，0，0，0

0，1，0，0，0

0，0，0，2，0

0，0，0，0，0

这个棋盘目前有一枚黑色棋子和一枚白色棋子，其余没有棋子的地方都是0，这样的一个数组因为含有想大量的相同值，浪费了太多的空间，因此的，稀疏数组就应运而生了。

稀疏数组

当一个数组含有大量重复的相同的值的时候，这个数组就可以转化为稀疏数组进行表示

稀疏数组共有3列，第一行记录的是原数组的行数，列数，有效数据的个数，比如上面的就为2

接下来的每一行，三列分别记录的是第一个有效数据的行下标，列下标，有效数据的值，依次类推

上面的数组表示为稀疏数组为：

4，5，2

1，1，1

2，3，2

用代码实现数组转化为稀疏数组，存入文件，然后从文件中取出，最后再还原为原数组

原数组转化为稀疏数组的思路：

1、统计原数组的行数，列数，有效数据的个数

2、创建稀疏数组

3、有效数据填充到稀疏数组中

稀疏数组还原为原数组的思路：

1、获取稀疏数组第一行的信息，创建原数组

2、读取稀疏数组其他行的信息，填充创建的新数组

/*
 * 原始数组转化为稀疏数组,
 * 稀疏数组保存到文件中
 * 从文件中读取稀疏数组
 * 还原为原数组
 */
public class ArrayToSparsearray {

    public static void main(String[] args) {
        // 原始数组转化为稀疏数组

        int[][] arr = new int[10][10];
        arr[2][3] = 2;
        arr[3][4] = 3;

        // 原数组
        System.out.println("原数组为：");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                System.out.print(arr[i][j] + "  ");
            }
            System.out.println();
        }

        // 求原数组有效数据的个数
        int sum = 0;// 用来存放有效数据的个数
        for (int[] is : arr) {
            for (int a : is) {
                if (a != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效数据个数sum=" + sum);

        // 创建稀疏数组
        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = arr.length;
        sparseArray[0][1] = arr[0].length;
        sparseArray[0][2] = sum;

        // 给稀疏数组填充数据
        int count = 1;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0) {
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = arr[i][j];
                    count++;
                }
            }
        }

        System.out.println("稀疏数组为：");
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[0].length; j++) {
                System.out.print(sparseArray[i][j] + "	");
            }
            System.out.println();
        }

        // 稀疏数组存入文件中
        File file = new File("./a.txt");
        FileOutputStream fileOutputStream = null;
        try {
            file.createNewFile();
            fileOutputStream = new FileOutputStream(file);
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < sparseArray.length; i++) {
                stringBuilder.append(sparseArray[i][0] + "  " + sparseArray[i][1] + "  " + sparseArray[i][2] + "
");
            }
            fileOutputStream.write(stringBuilder.toString().getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 从文件中读取稀疏数组
        FileReader fileReader = null;
        BufferedReader bufferedReader = null;
        int[][] sparseArray1 = new int[3][3];
        try {
            fileReader = new FileReader(file);
            bufferedReader = new BufferedReader(fileReader);
            String string = "";
            String[] arr1 = null;
            int t = 0;
            while ((string = bufferedReader.readLine()) != null) {
                arr1 = string.split("  ");
                sparseArray1[t][0] = Integer.valueOf(arr1[0]);
                sparseArray1[t][1] = Integer.valueOf(arr1[1]);
                sparseArray1[t][2] = Integer.valueOf(arr1[2]);
                t++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fileReader.close();
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        System.out.println("从文件读取的稀疏数组为：");
        for (int i = 0; i < sparseArray1.length; i++) {
            for (int j = 0; j < sparseArray1[0].length; j++) {
                System.out.print(sparseArray1[i][j] + "	");
            }
            System.out.println();
        }

        // 读取的稀疏数组转化为原始数组sparseArray1——>arr2
        int[][] arr2 = new int[sparseArray1[0][0]][sparseArray1[0][1]];
        for (int i = 1; i < sparseArray1.length; i++) {
            arr2[sparseArray1[i][0]][sparseArray1[i][1]] = sparseArray1[i][2];
        }
        
        System.out.println("转化后的原数组为：");
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[0].length; j++) {
                System.out.print(arr2[i][j] + "  ");
            }
            System.out.println();
        }

    }

}