原数组转稀疏数组，稀疏数组转原数组，稀疏数组写入磁盘，从磁盘恢复原数组

代码实现

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;

public class SparseArray {
    public static void main(String[] args) {
        //初始化原数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][4] = 2;

        System.out.println("****************************原数组****************************");
        traverse(array);

        System.out.println("****************************原数组转稀疏数组****************************");
        int[][] sparseArray = oldTosparse(array);
        //遍历稀疏数组
        traverse(sparseArray);

        System.out.println("****************************稀疏数组转原数组****************************");
        int[][] oldArray = sparseToold(sparseArray);
        //遍历稀疏数组
        traverse(oldArray);

        System.out.println("****************************将稀疏数组写入到磁盘中****************************");
//        try {
//            boolean flag = sparseArrayToio(sparseArray);
//            if (flag){
//                System.out.println("写入成功");
//            }
//        }catch (Exception e){
//            e.printStackTrace();
//        }

        //上述写入步骤成功后，在做读取时需把写入的注释掉，避免重复写入
        System.out.println("****************************从磁盘中恢复原数组****************************");
        try {
            sparseArrayFromIo(); 
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    //将稀疏数组写入到磁盘中
    public static boolean sparseArrayToio(int[][] sparseArray) throws Exception{
        boolean flag = false;
        File file = new File("test/File/sparseArray.txt");
        if (!file.exists()){
            file.createNewFile();
        }
        FileWriter fileWriter = new FileWriter(file);
        for (int i=0;i< sparseArray.length;i++){
            for (int j=0;j< sparseArray[i].length;j++){
                if(j!= sparseArray[i].length-1){
                    fileWriter.write(sparseArray[i][j]+"\t");
                }else{
                    fileWriter.write(sparseArray[i][j]+"");
                }
            }
            fileWriter.write("\n");
        }
        fileWriter.flush();
        fileWriter.close();
        flag = true;
        return flag;
    }

    //从磁盘中恢复数组
    public static void sparseArrayFromIo( ) throws Exception {
        FileReader reader = new FileReader("test/File/sparseArray.txt");
        BufferedReader bf = new BufferedReader(reader);
        ArrayList<String> arrayList = new ArrayList<>();
        String str;
        // 按行读取字符串
        while ((str = bf.readLine()) != null) {
            arrayList.add(str);
        }
        if (arrayList.size() == 0){
            System.out.println("文件为空");
            return;
        }
        int[][] sparseArray = new int[arrayList.size()][3];
        for(int i = 0;i < sparseArray.length;i++) {
            for (int j = 0; j < sparseArray[i].length; j++) {
                sparseArray[i][j] = Integer.parseInt(arrayList.get(i).split("\t")[j]);
            }
        }
        arrayList.clear();
        int[][] oldArray = new int[sparseArray[0][0]][sparseArray[0][1]];
        //将有效数填回原数组,
        for (int i=1;i<=sparseArray[0][2];i++){
            oldArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //遍历稀疏数组
        traverse(oldArray);
    }
    //遍历二维数组
    public static void traverse(int[][] array){
        for (int[] row : array) {
            for (int item : row) {
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }
    }
    //将稀疏数组转为原数组
    public static int[][] sparseToold(int[][] sparseArray){
        int[][] oldArray = new int[sparseArray[0][0]][sparseArray[0][1]];
        //将有效数填回原数组
        for (int i=1;i<=sparseArray[0][2];i++){
            oldArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return oldArray;
    }
    //原数组转稀疏数组
    public static int[][] oldTosparse(int[][] oldArray){
        int sum = 0;
        for (int i=0;i<oldArray.length;i++){
            for (int j=0;j<oldArray[i].length;j++){
                if(oldArray[i][j] != 0){
                    sum++;
                }
            }
        }
        //创建稀疏数组
        int[][] sparseArray = new int[sum+1][3];//稀疏数组始终为3列，行数为有效数+1
        //稀疏数组的第一行始终是原数组的行数、列数、有效值数
        sparseArray[0][0] = oldArray.length;
        sparseArray[0][1] = oldArray[0].length;
        sparseArray[0][2] = sum;
        //将有效数放入稀疏数组中
        //count:表示第几个有效数
        int count = 0;
        for (int i=0;i<oldArray.length;i++){
            for (int j=0;j<oldArray[i].length;j++){
                if(oldArray[i][j] != 0){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = oldArray[i][j];
                }
            }
        }
        return sparseArray;
    }
}