Java代码详细实现稀疏数组的转换，稀疏数组与二维数组的互相转换，二维数组转稀疏数组存文件，再读取文件将稀疏数组恢复成二维数组

稀疏数组与二维数组的互相转换

1、二维数组转稀疏数组

2、稀疏数组存文件

3、从文件读取稀疏数

4、稀疏数组还原二维数组

package com.ja.sparseArray;

import java.io.*;
/**
 * 稀疏数组练习
 * 创建二维数组 --》 转换稀疏数组 --》 存文件 --》 读取--》 还原二维数组
 */
public class SparseArray {

    public static void main(String[] args){
        int[][] arr;//二维数组
        int[][] sparseToArrs;//文件读取的稀疏数组还原二维数组
        int[][] sparseArr;//二数组转的稀疏
        int[][] fileSparseArr;//文件读取的稀疏数组
        //创建二维
        arr=creatArr();
        //遍历二维数组
        System.out.println("创建的二维数组：");
        forArr(arr);

        //二维数组转稀疏数组
        sparseArr=arrToSparseArr(arr);
        System.out.println("\n创建的二维数组转稀疏数组：");
        forArr(sparseArr);

        //存稀疏数组盘
        saveSparse(sparseArr);


        // 文件读取稀疏数组
        fileSparseArr= fileReadSparse();
        System.out.println("\n文件读取的稀疏数组：");
        forArr(fileSparseArr);

        //文件读取的稀疏数组转二维数组
        sparseToArrs=sparseToArr(fileSparseArr);
        System.out.println("\n文件读取的稀疏数组还原二维数组：");
        forArr(sparseToArrs);
    }

    /**
     * 文件读取稀疏数组
     *
     * @return spare 稀疏数组
     */

    private static int[][] fileReadSparse() {
        int[][] spare=null;
        String path="d:/aa/data.demo";//读取路径
        try {
            //第一次读取获得行数创建 [?][3]spare的稀疏数组
            BufferedReader in=  new BufferedReader(new InputStreamReader(new FileInputStream(path),"utf-8"));
            int row=0;//行数
            String line;
            //一行一行读取
            while((line=in.readLine())!=null){
                row++;
            }
            //创建稀疏数组spare
            spare=new int[row][3];

            //第二读取给稀疏数组存值[?][3]spare ?=row
            BufferedReader againIn=  new BufferedReader(new InputStreamReader(new FileInputStream("d:/aa/data.demo"),"utf-8"));
            int r=0;//稀疏数组行下标
            while((line=againIn.readLine())!=null){
                //读一行存入稀疏数组一行
               String [] arr=line.split(" ");//空格分隔出一个数组
                for (int i = 0; i < arr.length; i++) {
                    spare[r][i]=Integer.parseInt(arr[i]);
                }
                r++;
            }
            in.close();
//            //输出读取的数组
//            System.out.println("输出读取的数组");
//            forArr(spare);
            System.out.println("读取稀疏数组成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return spare;
    }

    /**
     * 稀疏数组存盘
     * @param sparseArr 存盘的稀疏数组
     */
    private static void saveSparse(int[][] sparseArr) {
        String path="d:/aa/data.demo";//存放路径
        try {
           PrintWriter out= new PrintWriter(new OutputStreamWriter(new FileOutputStream(path),"utf-8"));
            for (int i = 0; i <sparseArr.length; i++) {
                for (int j = 0; j < sparseArr[1].length; j++) {
                    out.print(sparseArr[i][j]+" ");
//                    System.out.print(sparseArr[i][j]);
                }
                out.println();
            }
            System.out.println("稀疏数组存盘成功！！！");
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 稀疏数组转二维数组
     * @param sprseArr
     * @return
     */
    private static int[][] sparseToArr(int[][] sprseArr) {
        /* [][]sparse   row col value    稀疏数组第一行
                        11  5   2
                        ·······
                        sparse[0][0] -- 11 二维数组的行
                        sparse[0][1] -- 5  二维数组的列
                        sparse[0][2]  -- 2  二维数组有效值

                        sparse[1+][0] -- ？ 二维数组有效数据的行
                        sparse[1+][1] -- ？ 二维数组有效数据的列
                        sparse[1+][2]  -- ？ 二维数组有效数据值

         */
        //获取稀疏数组（0,0）=row （0,1）=col 创建二维数组[row][col]arr
        int row=sprseArr[0][0];
        int col=sprseArr[0][1];
        int[][] arr=new int[row][col];

        //读取第二行后的数据存入二维数组
        for (int i = 1; i < sprseArr.length; i++) {
                arr[sprseArr[i][0]][sprseArr[i][1]]=sprseArr[i][2];
        }
        return arr;
    }

    /**
     * 二维数组转稀疏数组
     * @param arr
     * @return
     */
    private static int[][] arrToSparseArr(int[][] arr) {
        //1遍历二维数组得到有效数据个数
        int sum=forArr(arr,1);

        //定义稀疏数组
        int[][] sparseArr=new int[sum+1][3];

        //2给稀疏数组第一行赋值 [0][0]二维数组行 [0][1]列 [0][3]有效值个数
        sparseArr[0][0]=arr.length;
        sparseArr[0][1]=arr[0].length;
        sparseArr[0][2]=sum;

        //遍历二维数组把有效值放在稀疏数组中
        sparseArr=forArr(arr,sparseArr);

        return sparseArr;
    }

    /**
     * 遍历二维数组中的有效值给稀疏数组
     * @param arr 二维数组
     * @param sparseArr 稀疏数组
     * @return
     */
    private static int[][] forArr(int[][] arr,int[][] sparseArr) {
        int n=1;//稀疏数组存放从第二行开始
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0){
                    sparseArr[n][0]=i;
                    sparseArr[n][1]=j;
                    sparseArr[n][2]=arr[i][j];
                    n++;
                }
            }
        }
        return sparseArr;
    }

    /**
     * 遍历输出二维数组
     * @param arr 二维数组
     */
    private static int forArr(int[][] arr) {
        for (int[] row:arr
             ) {
            for (int number :
                    row) {
                System.out.print(number+" ");
            }
            System.out.println();
        }
        return 0;
    }

    /**
     * 遍历返回二维数组的有效个数
     * @param arr
     * @param notNumber 没有意义的值
     * @return
     */
    private static int forArr(int[][] arr,int notNumber) {
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0){  sum++;  }
            }
        }
        return sum;
    }
    /**
     * 创建11*5 （1,2）=1（2,3）=2的二维数组
     *
     * @return arr 二维数组
     */
    private static int[][] creatArr() {
        int row=11;//二维数组的行
        int col=5;//二维数组的里列
        int[][] arr=new int[row][col];
        //设置稀疏数组有效个数
        arr[1][2]=11;
        arr[2][3]=2;
        arr[3][4]=1;
        return arr;
    }
}

运行结果

创建的二维数组：
0 0 0 0 0 
0 0 11 0 0 
0 0 0 2 0 
0 0 0 0 1 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

创建的二维数组转稀疏数组：
11 5 3 
1 2 11 
2 3 2 
3 4 1 
稀疏数组存盘成功！！！
读取稀疏数组成功！！！

文件读取的稀疏数组：
11 5 3 
1 2 11 
2 3 2 
3 4 1 

文件读取的稀疏数组还原二维数组：
0 0 0 0 0 
0 0 11 0 0 
0 0 0 2 0 
0 0 0 0 1 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

Process finished with exit code 0
Process finished with exit code 0