稀疏数组简单使用

目录

1、什么是稀疏数组

2、简单使用

3、将稀疏数组存入文件后再读取并还原为二维数组

 1、什么是稀疏数组

假如有一个二维数组，里面只存了少数的值，然后我们需要将这个数组持久化到磁盘文件，在此之前请先想想，既然只存了少数的值，那么代表着这个二维数组的大部分位置都是没有值的，那么没有值的这些位置都是无意义的，我们不必要将这些没有值的位置都存储到磁盘中，那么这个时候为了解决类似这种问题，稀疏数组诞生了！

先来给刚才的二维数组画一个图:

假设这我们需要保存到磁盘的那个二维数组，用Java代码表示为：int [][] = new int[11][11];

我们对这个二维数组认为，只要不为0的值就是有意义的值。

现在这个二维数组中有值的数据用红色标注了出来，现在我们需要将这么一个二维数组存储到磁盘文件中，但是这个二维数组中有太多的空值，存储到磁盘的时候会浪费一些空间，那么这个时候就可以应用稀疏数组。

根据刚才的二维数组图，我们应用稀疏数组后，稀疏数组的图为：

这个稀疏数组在Java代码中表示为：int [][] = new int[5][3];

解释一下这个稀疏数组立面值的意思：

　　稀疏数组中第一行数据意义为：原二维数组的行，原二维数组的列，原二维数组中共有多少有意义的值

　　其余行数据意义为：原二维数组中数据有意义的行、列、值，需要注意的是存储的行、列都是下标

利用这种方式将原二维数组转换为一个稀疏数组，然后再将稀疏数组存入到磁盘，需要读取时，读取到稀疏数组，然后再转换为二维数组。

　　如将原二维数组直接存入到磁盘，则为11*11，现转换为稀疏数组只需要5*3，所以稀疏数组在这种场景下还是有很大的用处的。

 2、简单使用，二维数组与稀疏数组的互转

/**
 * @author 自在仙
 * @create 2020年04月12  20:15
 */
public class Test {
    public static void main(String[] args) {

        /*创建一个二维数组*/
        int[][] chess1 = new int[11][11];
        chess1[1][2] = 1;
        chess1[2][3] = 2;
        /*展示一下原来的二维数组*/
        show(chess1);

        /*因为稀疏数组的总行数取决于原二维数组有有意义的值+1，所以我们要先计算出原二维数组中有多少个有意义的值*/
        /*获得稀疏数组的总有效数据个数*/
        int sum = 0;
        /*循环遍历原二维数组，计算总有意义值的个数*/
        for (int[] ints : chess1) {
            for (int anInt : ints) {
                /*如果不等于0，那么我们认为其有意义*/
                if (anInt != 0) {
                    sum++;
                }
            }
        }

        /*
        * 创建我们的稀疏数组，
        *   第一个大小为sum+1，为什么要+1，因为第一行记录的是原二维数组的行和列，所以需要多占一行
        *   第二个大小固定为3，因为我们存储的是行、列、值，所以固定的是三个
        * */
        int[][] sparse = new int[sum + 1][3];

        /*第一列存储的是原二维数组的长度和有效值数量*/
        /*原二维数组行*/
        sparse[0][0] = chess1.length;
        /*原二维数组列*/
        sparse[0][1] = chess1[0].length;
        /*共有多少个值*/
        sparse[0][2] = sum;

        /*遍历原二维数组，将其有意义的数据存放至稀疏数组中去*/
        int sparseIndex = 1;
        for (int i = 0; i < chess1.length; i++) {
            for (int j = 0; j < chess1[i].length; j++) {
                /*如果不为0则是有意义的，存放*/
                if (chess1[i][j] != 0) {
                    sparse[sparseIndex][0] = i;
                    sparse[sparseIndex][1] = j;
                    sparse[sparseIndex][2] = chess1[i][j];

                    sparseIndex++;
                }
            }
        }
        System.out.println("----------------");
        /*二维数组到稀疏数组存放完了，展示一下*/
        show(sparse);
        /*稀疏数组就转圜完了*/


        /*------------------------------然后再由稀疏数组转换为二维数组-------------------------------------*/
        /*创建二维数组，行和列都是存储在稀疏数组的第一行中*/
        int[][] chess2 = new int[sparse[0][0]][sparse[0][1]];
        /*然后将稀疏数组中其他数据填充到二维数组中*/
        for (int i = 1; i < sparse.length; i++) {
            /*稀疏数组第一个元素是行，第二个是列，第三个是实际的值*/
            chess2[sparse[i][0]][sparse[i][1]] = sparse[i][2];
        }
        /*这样就把稀疏数组转换回了二维数组*/
        System.out.println("-------------------------------");
        /*转换回二维数组后再展示一下*/
        show(chess2);
    }

    
    /*打印数组的方法*/
    public static void show(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "	");
            }
            System.out.println();
        }
    }
}

 3、将稀疏数组存入文件后读取并还原为二维数组

只要能写出上面的简单使用，这个存文件读取就没问题的

/**
 * @author 自在仙
 * @create 2020年04月12  22:07
 */
public class Test2 {

    /*
     * 练习：
     *   将二维数组转换为稀疏数组，然后存入文件，然后再读取为稀疏数组，然后再转换为二维数组
     * */

    public static void main(String[] args) throws IOException {
        /*原二维数组*/
        int[][] chess = new int[12][12];
        chess[1][2] = 2;
        chess[2][3] = 1;
        chess[3][4] = 2;

        System.out.println("----------原数组---------");
        showArray(chess);

        /*转换为稀疏数组*/
        /*先拿到原数组的总有效值数量*/
        int sum = 0;
        for (int[] ints : chess) {
            for (int anInt : ints) {
                if (anInt != 0) {
                    sum++;
                }
            }
        }
        /*得到一个稀疏数组，然后将原数组中的内容转到稀疏数组中*/
        int[][] sparse = new int[sum + 1][3];
        sparse[0][0] = chess.length;
        sparse[0][1] = chess[0].length;
        sparse[0][2] = sum;
        int sparseIndex = 1;
        for (int i = 0; i < chess.length; i++) {
            for (int i1 = 0; i1 < chess[i].length; i1++) {
                if (chess[i][i1] != 0) {
                    /*第一个存原二维数组的行。*/
                    sparse[sparseIndex][0] = i;
                    /*第二个存原二维数组的列*/
                    sparse[sparseIndex][1] = i1;
                    /*第三个存实际的值*/
                    sparse[sparseIndex][2] = chess[i][i1];
                    sparseIndex++;
                }
            }
        }
        System.out.println("----------稀疏数组---------");
        showArray(sparse);

        /*----------------------开始存入文件--------------------------*/
        /*获得文件地址*/
        String test2TextPath = Test2.class.getClassLoader().getResource("test2.txt").getPath();
        File file = new File(test2TextPath);
        if (!file.exists()) {
            file.createNewFile();
        }
        /*获得输出流写文件*/
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
        for (int[] ints : sparse) {
            /*
            * 写入格式为
            *  11 11 5
            *  1 1 2
            * 每行的元素之间间隔一个空格，行与行之间换行
            * */
            bufferedWriter.write(ints[0] + " " + ints[1] + " " + ints[2]);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
        System.out.println("稀疏数组已经存入文件:" + file.getAbsolutePath());
        /*------------------------开始文件中读取稀疏数组--------------------------*/
        /*读取稀疏数组文件到数组中*/
        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
        String readDataTemp = null;
        /*记录总行数，方便创建稀疏数组*/
        int indexTemp = 0;
        while ((readDataTemp = bufferedReader.readLine()) != null) {
            indexTemp++;
        }
        /*读取完一次后，关闭，重新读取文件*/
        bufferedReader.close();
        /*重新赋值读取文件*/
        bufferedReader = new BufferedReader(new FileReader(file));
        /*根据上方获得的总记录数，创建稀疏数组*/
        int[][] sparse2 = new int[indexTemp][3];
        /*记录每次添加的索引*/
        indexTemp = 0;
        /*读取到数据后填充到稀疏数组中*/
        while ((readDataTemp = bufferedReader.readLine()) != null) {
            System.out.println("readDataTemp:" + readDataTemp);
            /*每一行的数据都进行拆分，*/
            String[] s = readDataTemp.split(" ");
            /*分别填充到三列中*/
            sparse2[indexTemp][0] = Integer.valueOf(s[0]);
            sparse2[indexTemp][1] = Integer.valueOf(s[1]);
            sparse2[indexTemp][2] = Integer.valueOf(s[2]);
            indexTemp++;
        }
        System.out.println("----------读取文件中的稀疏数组---------");
        showArray(sparse2);

        /*------------------------将读取到的稀疏数组转换为二维数组----------------------------*/
        /*将读取到的稀疏数组转换为二维数组*/
        int[][] chess2 = new int[sparse2[0][0]][sparse2[0][1]];
        for (int i = 1; i < sparse2.length; i++) {
            chess2[sparse2[i][0]][sparse2[i][1]] = sparse2[i][2];
        }
        System.out.println("----------转换为二维数组---------");
        showArray(chess2);
    }
    
    /*打印数组的方法*/
    public static void showArray(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}