二维数组和稀疏数组互转，二维数组文件读写

稀疏数组的基本概念

• 记录数组一共有几行几列，有多少不同的值。
• 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。该小规模数组就是稀疏数组

稀疏数组的用途
可以将原始的二维数组进行简单化存储，缩小占用空间

稀疏数组应用案例
五子棋棋盘二维数组存储，转为稀疏数组存储

代码实现

• 二维数组转稀疏数组
• 稀疏数组转二维数组
• 二维数组写入文件
• 读取文件转化为二维数组

package com.structure.sparse;

import com.alibaba.fastjson.JSON;
import java.io.*;
import java.nio.charset.Charset;

/**
 * @author zzq
 * @Date 2021-07-14 15:54
 */
public class SparseArrayDemo {

    public static void main(String[] args) throws Exception {

        //定义一个二维数组，初始化是是一个11*11的全为0的空数组
        int[][] arr = new int[11][11];
        //初始数组
        printArr(arr);
        System.out.println();
        System.out.println("····················································");
        System.out.println();
        //数组中放入数据
        arr[1][1]=2;
        arr[2][3]=3;
        arr[5][6]=6;
        //填充数据后的数组
        printArr(arr);
        System.out.println("····················································");

        //二维数组 -> 稀疏数组
        int[][] sparseArr = convertSparseArr(arr);
        printArr(sparseArr);
        System.out.println("····················································");

        //稀疏数组 -> 二维数组
        int[][] arr2 = sparseConvertArr(sparseArr);
        printArr(arr2);
        System.out.println("····················································");

        //稀疏数组写文件
        writeArr(sparseArr);
        //从文件读稀疏数组
        int[][] sparseArr2 = readArr();
        printArr(sparseArr2);
    }

    /**
     * 二维数组转稀疏数组
     * 稀疏数组的列是固定的3列，行=二维数组的元素个数+1
     * @param arr
     * @return
     */
    private static int[][] convertSparseArr(int[][] arr){
        //第一步，初始化稀疏数组
        //元素个数
        int num = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0){
                    num++;
                }
            }
        }

        //因为稀疏数组第一行存放的是原始数组的大小,所以num要加1
        int[][] sparseArr = new int[num+1][3];
        //第二部，稀疏数组第一行赋值
        //长
        sparseArr[0][0] = arr.length;
        //宽
        sparseArr[0][1] = arr[0].length;
        //元素个数
        sparseArr[0][2] = num;

        //填充稀疏数组
        //稀疏数组的列控制
        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++;
                }
            }
        }

        return sparseArr;
    }

    /**
     * 稀疏数组转二维数组
     * @param sparseArr
     * @return
     */
    private static int[][] sparseConvertArr(int[][] sparseArr){
        //初始化二维数组，稀疏数组第一行放的是原始数组的大小
        int[][] arr = new int[sparseArr[0][0]][sparseArr[0][1]];

        //i从第2行开始
        for (int i = 1; i < sparseArr.length; i++) {
            //第i行第一列是横坐标，第二列是纵坐标，第三列是元素值
            arr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        return arr;
    }


    /**
     * 打印数组
     * @param arr
     */
    private static void printArr(int[][] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.printf("%d\t",arr[i][j]);
            }
            System.out.println();
        }
    }



    /**
     * 数组写入文件
     * @param arr
     */
    private static void writeArr(int[][] arr) throws IOException {
        File file = new File("src/main/resources/1.text");

        FileOutputStream fos = new FileOutputStream(file);
        Writer pw = new OutputStreamWriter(fos, Charset.forName("utf-8"));
        pw.write(JSON.toJSONString(arr));
        pw.close();
    }

    private static int[][] readArr() throws Exception{
        File file = new File("src/main/resources/1.text");
        //构造一个BufferedReader类来读取文件
        BufferedReader br = new BufferedReader(new FileReader(file));
        StringBuilder result = new StringBuilder("");
        String s = null;
        while((s = br.readLine())!=null){
                //使用readLine方法，一次读一行
                result.append("\n" +s) ;
            }
         br.close();
        int[][] parse = JSON.parseObject(result.toString(), int[][].class);
        return parse;
    }
}

用到的依赖如下

		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.66</version>
        </dependency>