数据结构java：稀疏数组转换。关于流的一些问题

一.关于flush和close方法
简单地说，flush之后还能继续使用流，但是close之后就用不了了
https://wenku.baidu.com/view/bf9eec97f221dd36a32d7375a417866fb84ac0b3.html
https://www.imooc.com/article/12969
https://www.bilibili.com/video/BV1PD4y1U7ky?p=18
二、关于list和ArrayList区别（类 实例化，填个坑以后学到慢慢看了）
javashuo.com/article/p-abqmfiqj-hx.html
https://baijiahao.baidu.com/s?id=1715051808653426749&wfr=spider&for=pc
三、为什么file和异常放在一起学习？
因为关于文件的异常是checked exception。checked Exception就是在写代码的时候，需要写try catch的Exception，这种Exception一般不会影响主体程序，可以由程序员手动诊断修复异常。
https://baijiahao.baidu.com/s?id=1670155973940817642&wfr=spider&for=pc
https://blog.csdn.net/qq_41800568/article/details/98105908
四、File方法里注意mkdir和createNewFile方法
五、try括号里能加什么
http://www.javashuo.com/article/p-hfgdhcdu-hs.html
https://www.cnblogs.com/lovelp/p/4545282.html
六、Bufferedwriter和writer的区别
https://www.jianshu.com/p/49b23f49814c
七。parseint和valueof区别：
https://segmentfault.com/q/1010000005337462
八、printf
https://www.cnblogs.com/soberw/p/15876473.html

package guigu;

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

public class SparseArray {

public static void main(String[] args) {
    /*一、二维数组转换稀疏数组
    0、创建一个二维数组
    1.遍历二维数组，获取有效值
    2.根据有效值初始化稀疏数组
    3.为稀疏数组赋值
    */


    //0、创建一个二维数组
    int chessArr1[][] = new int[11][11];
    chessArr1[1][2] = 2;
    chessArr1[2][4] = 3;


    //1.遍历二维数组，获取有效值
    int sum = 0;
    for (int[] row : chessArr1) {
        for (int data : row) {
            if (data != 0) {
                sum++;
            }
        }
    }
    //2.根据有效值初始化稀疏数组
    int sparseArr[][] = new int[sum + 1][3];
    //3.为稀疏数组赋值
    sparseArr[0][0] = 11;
    sparseArr[0][1] = 11;
    sparseArr[0][2] = sum;

    int count = 0;

    for (int i = 0; i < chessArr1.length; i++) {
        for (int j = 0; j < 11; j++) {
            if (chessArr1[i][j] != 0) {
                count++;
                sparseArr[count][0] = i;
                sparseArr[count][1] = i;
                sparseArr[count][2] = chessArr1[i][j];
            }
        }
    }
    //输出稀疏数组：
    for (int i = 0; i < count + 1; i++) {
        System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
    }


    //将稀疏数组恢复成二维数组

    //1.创建一个空的二维数组
    int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
    //2.根据稀疏数组数组为二维数组赋有效值
    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.printf("%d\t", data);
        }
        System.out.println();

    }

课后作业///

/*
思路：1.把文件中的内容变成一个装string的list
2.把list里每一个string切分变成int类型的数
3.组成数组
*/

    //将稀疏数组存到硬盘上
    //定义文件路径，如不存在，创建同名文件
    File file=new File("D:\\mapp.data");
    try {
        if (!file.exists()) {
            file.createNewFile();
        }
    }catch(Exception e){
        e.printStackTrace();

    }
    //准备写入文件
    FileWriter fw = null;
    BufferedWriter bw = null;
    try {
        fw = new FileWriter(file);
        bw = new BufferedWriter(fw);
        for (int[] row:sparseArr) {
            for(int data: row){
                //以字符串的形式写入
                bw.write(data+"\t");
            }
            bw.write("\n");
        }
        bw.close();
        fw.close();
       //
    } catch (Exception e) {
        e.printStackTrace();
    }

    //将稀疏数组读取出来
    FileReader fr = null;
    BufferedReader br = null;
    //声明这个稀疏数组
    int[][] sparseArrNew;
    //创建一个list，用来存放从硬盘中读取出来的数组
    List list = new ArrayList<>();
    
    //创建一个字符串暂时存放文件中读取出来的每一行的数据
    String line;
    //把得到的每一行字符串拆分，使每一行字符串变成一个字符串数组
    String[] strr;

    //稀疏数组的行数
    int countNew = 0;

    try {
        fr = new FileReader(file);
        br = new BufferedReader(fr);
     
        //将文件输入到list中去
        while((line=br.readLine())!=null){
            System.out.println(1);
            list.add(line);
            countNew++;
            //sparseArrNEW strs.split("\t");
        }



    } catch (Exception e) {
        e.printStackTrace();
    }
    //初始化稀疏数组
   
    sparseArrNew = new int[countNew][3];

    //为稀疏数组赋值
    int num = 0;
    for(String str:list){
        strr=str.split("\t");
        //使每一个字符串数组变成一个整数数组
        sparseArrNew[num][0] =Integer.valueOf(strr[0]);
        sparseArrNew[num][1] =Integer.valueOf(strr[1]);
        sparseArrNew[num][2] =Integer.valueOf(strr[2]);
        num++;
    }
    //输出稀疏数组
    for(int[]row:sparseArrNew){
        for(int data:row){
            System.out.printf("%d\t",data);
        }
        System.out.println();
    }
}

}