JAVA如何存储二维数组

直接存储二维数组的缺点

如果在二维数组中只使用了几个元素，就直接存储在内存中，这样会造成空间浪费。
由于直接使用二维数组会造成空间浪费，所以就引出了一个新的数组：稀疏数组。

稀疏数组介绍

稀疏数组的处理方法：
1）记录原二维数组的行数和列数，有多少个不同的值
2）把每个不同的值在原二维数组中的下标记录

3）稀疏数组的第一行的数据一定是原二维数组的行数和列数，和非0数字的个数
4）从第二行开始记录每个非0数组在原二维数组中的下标（第一列是行数，第二列是列数）

稀疏数组的应用场景

保存棋盘、地图

将稀疏数组转回原二维数组

首先需要获取稀疏数组的第一行数据，因为记录了原二维数组的行数和列数。然后从稀疏数组的第二行开始遍历即可还原

代码实现

package com.java.sparsearray;

import java.io.*;
import java.util.Vector;

/**
 * 稀疏数组：可以用来压缩二位数组
 */
public class SparseArray {
    /**
     * 从指定文件中取出稀疏数组，并返回
     * @param file ：指定文件
     * @return
     */
    private static  Vector<String> getSparseArrayFromFile(File file){
        //将稀疏矩阵从文件中读取出来
        BufferedReader bufferedReader = null;
        Vector<String> resArray=new Vector<>();
        try {
            InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file));
            bufferedReader = new BufferedReader(inputStreamReader);
            String line = null;
            //按行读取
            while((line = bufferedReader.readLine() )!= null){
                if(null != line){
                    //将文件中的每行数据存储在Vector对象中
                    resArray.add(line);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }


        return resArray;
    }
    public static void main(String[] args) throws IOException {
        //分别创建两个变量保存棋盘的行和列
        int chessRows=11;
        int chessCols=11;
        //创建一个棋盘数组
        int chessArray[][]=new int[chessRows][chessCols];

        //0:空 1：黑子 2：白子
        chessArray[2][5]=1;
        chessArray[4][6]=2;
        chessArray[3][6]=2;
        chessArray[3][1]=1;
        System.out.println("======棋盘如下=====");
        for (int[] i:chessArray) {
            for (int data:i) {
                System.out.print(data+"   ");

            }
            System.out.println();
        }

        System.out.println("=========将二维数组转换为稀疏数组==========");
        /**
         * 二维数组—>稀疏数组(固定三列)思路
         * 1.需要获取二维数组中非0数字有多少个(n)，进而可以知道稀疏数组由几行(n+1)
         */
        //创建一个变量存储非0数字的个数
        int noZeroCount=0;
        //遍历二维数组获取二维数组中非0数字的个数
        for (int[] chess:chessArray) {
            for (int data:chess) {
                if (data!=0){
                    noZeroCount++;
                }
            }
        }
        //创建稀疏数组
        int sparseArray[][]=new int[noZeroCount+1][3];
        //先为稀疏数组的第一行赋值
        sparseArray[0][0]=chessRows;
        sparseArray[0][1]=chessCols;
        sparseArray[0][2]=noZeroCount;
        //保存稀疏数组进行到第几行
        int currPosition=1;
        //遍历二维数组为稀疏数组赋值
        for(int i=0;i<chessArray.length;i++){
            for (int j=0;j<chessArray[i].length;j++){
                //获取二维数组中的每一个元素
                int data = chessArray[i][j];
                //判断是不是非0数字
                if(data!=0){
                    //将此元素的坐标存入稀疏数组中
                    sparseArray[currPosition][0]=i;
                    sparseArray[currPosition][1]=j;
                    sparseArray[currPosition][2]=data;
                    currPosition++;
                }
            }
        }
        //打印稀疏数组
        for(int [] sparse :sparseArray){
            for (int data:sparse){
                System.out.print(data+"   ");
            }
            System.out.println();
        }
        try{
            FileWriter writer=new FileWriter("d:\\sparseArray.txt");
            for (int i = 0; i < sparseArray.length; i++) {
                for (int j = 0; j < sparseArray[i].length; j++) {
                    //将int转换成字符串
                    String value = String.valueOf(sparseArray[i][j]);
                    writer.write(value+"\t");
                }
                writer.write("\r\n");
            }
            //关闭流
            writer.close();
            System.out.println("已将稀疏数组已存入磁盘中");
        }catch (Exception e){
            System.out.println(e.getMessage());
        }

        //从指定文件中取出稀疏数组
        Vector<String> sparseArrayFromFile = SparseArray.getSparseArrayFromFile(new File("d:\\sparseArray.txt"));
        //获取resArray对象的长度(也就是稀疏数组的行数)
        int sparseRows = sparseArrayFromFile.size();
        //创建一个稀疏数组
        int newSparseArray[][]=new int [sparseRows][3];
        //将sparseArrayFromFile对象赋值给newSparseArray对象
        for(int i=0;i<sparseArrayFromFile.size();i++) {
            String[] split = sparseArrayFromFile.get(i).split("\\t");
            for (int j = 0; j < split.length; j++) {
                newSparseArray[i][j]=Integer.parseInt(split[j]);
            }
        }
        System.out.println("======从文件中取出的稀疏数组如下=====");
        //遍历从文件中取出的稀疏数组
        for(int[] s:newSparseArray) {
            for(int data:s) {
                System.out.print(data+"   ");
            }
            System.out.println();
        }
        //将文件中取出的稀疏数组转换成原始二维数组
        System.out.println("==============将文件中取出的稀疏数组转换成原始二维数组====================");
        //获取稀疏数组的第一行元素
        int newChessRows = newSparseArray[0][0];//棋盘数组的行数
        int newChessCols=newSparseArray[0][1];//棋盘数组的列数
        //创建新的棋盘数组
        int newChessArray[][]=new int[newChessRows][newChessCols];
        //遍历稀疏数组
        for (int i = 1; i < newSparseArray.length; i++) {
            //取出稀疏数组当前行的所有数据
            int x = newSparseArray[i][0];//行坐标
            int y = newSparseArray[i][1];//列坐标
            int value=newSparseArray[i][2];//(x,y)
            //将稀疏数组的当前行赋值给新的棋盘数组
            newChessArray[x][y]=value;
        }
        //遍历新的棋盘数组
        for (int[] is : newChessArray) {
            for (int data : is) {
                System.out.print(data+"   ");
            }
            System.out.println();
        }



    }
}