稀疏数组及io写入和读取

package com.main.dataStructures;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//1.创建一个二维数组
//2.将二维数组转换为稀疏数组
//3.将稀疏数组保存到磁盘中
//4.读取磁盘中的文件，转换为稀疏数组
//5.将稀疏数组转换为二维数组
public class SparseArray {
    public static void main(String[] args) throws IOException {
        /*
         * 第 1 步：创建一个二维数组
         */
        //创建一个原始的二维数组11 * 11
        //0:表示没有棋子，1表示黑子，2表示白子
        int[][] arr = new int[11][11];
        arr[1][2] = 1;
        arr[2][3] = 2;
        System.out.println("原始的二维数组：");
        for (int[] ar :arr) {
            for (int data : ar) {
                System.out.printf("\t" + data);
            }
            System.out.println();
        }
        /*
         * 第 2 步:将二维数组转换为稀疏数组
         *
         * *将二维数组转换为稀疏数组的思想：
         * 1.先遍历二维数组，得到非 0 的数据个数
         * 2.创建对应的大小的稀疏数组
         * 3.再次遍历二维数组，将非 0 的值存入稀疏数组
         */
        //1.遍历二维数组 得到非0数据的个数sum
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0){
                    sum++;
                }
            }
        }
        //2.根据sum创建对应大小的稀疏数组
        int sparseArr[][] = new int[sum+1][3];
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
//        3.再次遍历二维数组，将非 0 的值存入稀疏数组
        int count = 0;
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arr[i][j];
                }
            }

        }
        // 输出稀疏数组
        System.out.println("稀疏数组为：");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        /*
         * 第 3 步:将稀疏数组保存到磁盘中
         */
        writeSparse(sparseArr);
        /*
         * 第 4 步:读取磁盘中的文件，转换为稀疏数组
         */
        int[][] sparseArr2 = readSparse();
        /*
         * 第 5 步:将稀疏数组转换为二维数组
         *
         * 1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
         * 2.再读取稀疏数组后几行的数据，并赋值给原始的二维数组
         */
        //如果读取的文件中有数据，那么将该稀疏数组转换为二维数组
        //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int [][]arr2 = new int[sparseArr2[0][0]][sparseArr2[0][1]];
        //2.再根据稀疏数组第二行记录的内容，更新二维数组
        for (int i = 1; i < sparseArr2.length; i++) {
            arr2[sparseArr2[i][0]][sparseArr2[i][1]] = sparseArr2[i][2];
        }
        //3.输出转换后的二维数组
        System.out.println("\n还原后的二维数组：");
        for (int[] ar :arr2) {
            for (int data : ar) {
                System.out.printf("\t" + data);
            }
            System.out.println();
        }
    }
    //将稀疏数组写入到磁盘中的方法
    public static void writeSparse(int[][] sparseArr) throws IOException {
        File file = new File("E:\\code\\sparseArray.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        FileWriter fileWriter = new FileWriter(file);
        for (int i = 0; i < sparseArr.length; i++) {
            //数据前n-1列尾部加入"\t"
            for (int j = 0; j < sparseArr[0].length-1; j++) {
                fileWriter.write(sparseArr[i][j]+"\t");
            }
            //数组最后一列后面不加"\t"
            fileWriter.write(sparseArr[i][sparseArr[0].length-1]+"");
            //换行
            fileWriter.write("\n");
        }
        fileWriter.flush();
        fileWriter.close();
    }

    //读取磁盘中的文件，转换为稀疏数组
    public static int[][] readSparse() throws IOException {
        File file1 = new File("E:\\code\\sparseArray.txt");
        FileReader fileReader = new FileReader(file1);
        //通过BufferedReader包装字符输入流
        BufferedReader readerBuf = new BufferedReader(fileReader);
        //创建一个集合，用来存放读取的文件的数据
        List<String> strList = new ArrayList<>();
        //用来存放一行的数据
        String lineStr;
        //逐行读取txt文件中的内容
        while((lineStr = readerBuf.readLine()) != null) {
            //9.把读取的行添加到list中
            strList.add(lineStr);
        }
        //获取文件有多少行
        int lineNum = strList.size();
        //根据文件行数创建对应的数组
        int [][]sparseArr = new int[lineNum][3];
        //记录输出当前行
        int count = 0;
        //循环遍历集合，将集合中的数据放入数组中
        for(String str : strList) {
            //将读取的str按照","分割，用字符串数组来接收
            String[] strs = str.split("\t");
            sparseArr[count][0] = Integer.valueOf(strs[0]);
            sparseArr[count][1] = Integer.valueOf(strs[1]);
            sparseArr[count][2] = Integer.valueOf(strs[2]);
            //将行数 + 1
            count++;
        }
        fileReader.close();// 关闭输入流，释放连接
        readerBuf.close();//关闭字符输入缓冲流
        return sparseArr;//返回稀疏数组
    }

}

结果如下：



原创：大佬博客