二维数组与稀疏数组的转换（文件读取版）

最近在做一点数据结构与算法，顺便复习一下javaSE基础。有什么不懂的可以私信我

package com.xihai.sparseArray;

import java.io.*;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/*
@author XiHai ShengGe
将二维数组转换为稀疏数组，并存储到文件中，读取文件恢复后进行输出
*/
public class SparseArray2 {

    //程序的主入口
    public static void main(String[] args) throws IOException {
        //定义二维数组数据
        int[][] array1 = new int[11][11];
        array1[0][0] = 1;
        array1[0][8] = 2;
        array1[1][5] = 1;
        array1[3][9] = 1;
        array1[5][10] = 2;
        array1[5][2] = 1;
        array1[6][3] = 2;
        array1[7][10] = 1;
        array1[9][0] = 1;
        array1[10][3] = 2;
        array1[10][10] = 1;
        array1[10][7] = 2;
        //获取数据的有效个数
        int count = getNumCount(array1);
        System.out.println("数组的个数：" + count);
        //获取稀疏数组
        int[][] sparseArr = getSparseArr(array1, count);
        //将稀疏数组写入到文件中
        writeToFile(sparseArr);
        //读取文件中的稀疏数组
        System.out.println("文件中的稀疏数组：");
        int[][] parseArrFromFile = getParseArrFromFile();
        for (int i = 0; i < parseArrFromFile.length; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(parseArrFromFile[i][j] + "\t");
            }
            System.out.println();
        }

        //创建二维数组，将稀疏数组转换为二维数组输出
        System.out.println("稀疏数组转换为二维数组");
        int[][] ints = sparseArrToOriginalArr(parseArrFromFile);
        for (int i = 0; i < ints.length; i++) {
            for (int j = 0; j < ints[i].length; j++) {
                System.out.print(ints[i][j] + "\t");
            }
            System.out.println();
        }
    }

    //遍历二维数组，统计得到有效数组个数
    public static int getNumCount(int[][] arr){
        //双重for循环，时间复杂度O(n^2)
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0){
                    count ++ ;
                }
            }
        }
        //使用map计算有效数组个数,这里只是为了打开一种思路，实际中不推荐使用
        /*Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (map.get(arr[i][j]) != null){
                    map.put(arr[i][j],map.get(arr[i][j]) + 1);
                }else {
                    map.put(arr[i][j],1);
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                count += map.get(arr[i][j]);
            }
        }*/
        return count;
    }

    //获取二维数组所对应的稀疏数组
    public static int[][] getSparseArr(int[][] arr,int count){
        //创建稀疏数组，有效个数为count+1
        int[][] sparseArr = new int[count+1][3];
        sparseArr[0][0] = arr.length;
        sparseArr[0][1] = arr.length;
        sparseArr[0][2] = count;
        int flag = 0;//用于统计非零元素个数
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0){
//                  System.out.println(sparseArr[flag][0] + "\t" + sparseArr[flag][1] + "\t" + sparseArr[i][2]);
                    flag++;
                    sparseArr[flag][0] = i;
                    sparseArr[flag][1] = j;
                    sparseArr[flag][2] = arr[i][j];
                }
            }
        }
        return sparseArr;
    }

    //将稀疏数组写入文件map.txt中
    public static void writeToFile(int[][] sparseArr) throws IOException {
        File file = new File("data.txt");
        if (!file.exists()) {
                file.createNewFile();
        }
        FileWriter fw = null;
        //FileWriter只能将字符串写入到文件中
        try {
            long startTime = new Date().getTime();
            System.out.println("开始写入：" + startTime);
            fw = new FileWriter(file);
            for (int i = 0; i < sparseArr.length; i++) {
                for (int j = 0; j < sparseArr[i].length; j++) {
                    fw.write(Integer.toString(sparseArr[i][j]));
                    fw.write(" "); //用来在分隔时进行区分
                }
                fw.write("\n");
            }
            fw.flush();
            long endTime = new Date().getTime();
            System.out.println("写入完毕 ：" + endTime);
            System.out.println("耗时 " + (endTime - startTime) + " 毫秒");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //读取文件中的稀疏数组
    public static int[][] getParseArrFromFile(){
        FileReader fr = null; //节点流（字节流与字符流）
        BufferedReader br = null; //包装流（缓冲流与处理流）
        File file = new File("data.txt");
        try {
            fr = new FileReader(file);
            br = new BufferedReader(fr);
            String line;
            String[] arrStr = null; //将文件中的每一行写入到字符串数组中
            int flag = 0;
            //创建index[x][3]的二维数组，行数待定，尽量选大，放置出现异常
            int[][] sparseArr = new int[15][3];
            while((line = br.readLine()) != null){
                arrStr = line.split(" ");
                for (int i = 0; i < arrStr.length; i++) {
                    sparseArr[flag][i] =  Integer.parseInt(arrStr[i]);
                }
                flag++;
            }
            //通过获取到flag值类确定真实的稀疏数组的行数
            int[][] a = new int[flag][3];
            for (int i = 0; i < flag; i++) {
                for (int j = 0; j < 3; j++) {
                    a[i][j] = sparseArr[i][j];
                }
            }
            return a;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    //将稀疏数组还原为原来的二维数组
    public static int[][] sparseArrToOriginalArr(int[][] sparseArr){
        int[][] originalArr = new int[sparseArr[0][0]][sparseArr[0][1]];
        //遍历稀疏数组，将非零数据写入到原始数组中
        for (int i = 0; i < sparseArr.length - 1; i++) {
            originalArr[sparseArr[i+1][0]][sparseArr[i+1][1]] = sparseArr[i+1][2];
        }
        return originalArr;
    }
}