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

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

public class SparseArrayDemo {

public static void main(String[] args) throws FileNotFoundException {
    //创建一个原始的二位数组
    int ChessArr1[][] = new int[11][11];
    ChessArr1[1][2] = 1;
    ChessArr1[2][3] = 2;
    ChessArr1[3][4] = 1;
    //输出原始的二维数组
    System.out.println("遍历的二维数组：");
    for (int[] row:ChessArr1){
        for (int data:row){
            System.out.print(data+"\t");
        }
        System.out.println();
    }

    //将二维数组转换成稀疏数组的思路
    //1.先判断二维数组中有多少个有效数
    int sum = 0;
    for (int i=0;i<11;i++){
        for (int j=0;j<11;j++){
            if (ChessArr1[i][j]!=0){
                sum++;
            }
        }
    }
    System.out.println("二维数组中共有有效数："+sum+"个");

    //创建对应的稀疏数组
    int SparseArr[][] = new int[sum+1][3];
    //给稀疏数组赋值
    SparseArr[0][0] = 11;
    SparseArr[0][1] = 11;
    SparseArr[0][2] = sum;
    //遍历二维数组，将非0的之存放到稀疏数组
    int count = 0;
    for (int i = 0;i<11;i++){
        for (int j=0;j<11;j++){
            if (ChessArr1[i][j]!=0){
                count++;
                SparseArr[count][0] = i;
                SparseArr[count][1] = j;
                SparseArr[count][2] = ChessArr1[i][j];
            }
        }
    }
    //遍历稀疏数组
    System.out.println("得到的稀疏数组为：");
    for (int i=0;i<SparseArr.length;i++){
        System.out.print(SparseArr[i][0]+"\t"+SparseArr[i][1]+"\t"+SparseArr[i][2]);
        System.out.println();
    }

    //将稀疏数组转换成二维数组
    //1.先读取稀疏数组的第一行，创建原始二维数组
    //2.读取稀疏数组的后几行数据并赋值给原始数据
    int ChessArr2[][] = new int[SparseArr[0][0]][SparseArr[0][1]];
    System.out.println("输出恢复后的二维数组：");
    for (int i=1;i<SparseArr.length;i++){
        //将有效值赋给新创建的二维数组
        ChessArr2[SparseArr[i][0]][SparseArr[i][1]] = SparseArr[i][2];
    }
    //遍历新的二维数组
    for (int[] row:ChessArr2){
        for (int data:row){
            System.out.print(data+"\t");
        }
        System.out.println();
    }

    //将稀疏数组保存到硬盘上
    File dest=new File("D:\\Demo01.txt");

    try (BufferedWriter bw=new BufferedWriter(new FileWriter(dest));){
        for(int[] row:SparseArr) {
            for(int data:row) {
                bw.write(data+"\t");
            }
            bw.write("\n");

            bw.flush();//刷新
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    //从硬盘读取稀疏数组，并进行恢复

    //获取硬盘中稀疏数组的行数，并将其存储到一个list中
    File src=new File("D:\\Demo01.txt");
    BufferedReader br=null;
    List<Integer> list=new ArrayList<>();
    try{
        br=new BufferedReader(new FileReader(src));
        String line;
        while((line=br.readLine())!=null) {
            String[] str=line.split("\t");
            for(int i=0;i<str.length;i++) {
                list.add(Integer.parseInt(str[i]));
            }
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(br!=null) {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //打印稀疏数组行数
    System.out.println("稀疏数组的行数为：  "+(list.get(2)+1));//第三个元素代表不为0的元素有多少个，+1代表稀疏数组的行数

    //从硬盘读取稀疏数组到内存种的方法二：直接对之前的list进行操作
    //创建稀疏数组
    int sparseArr2[][]=new int[(list.get(2)+1)][3];
    int j=0;
    for(int i=0;i<list.size();i+=3) {
        sparseArr2[j][0]=list.get(i);
        sparseArr2[j][1]=list.get(i+1);
        sparseArr2[j][2]=list.get(i+2);
        j++;
    }

    System.out.println("--------------从硬盘种读取的稀疏数组--------------");
    for(int[] row2:sparseArr2) {
        for(int data:row2) {
            System.out.printf("%d\t",data);
        }
        System.out.println();
    }

}