java演示稀疏数组的使用(包括读入文件和写入文件的操作)-------参考视频 韩顺平《java数据结构和算法》

文件的操作记得修改文件的路径
完整代码如下：

package com.wqc.sparsearray;

import java.io.*;

/**
 * @author 高瞻远瞩
 * @version 1.0
 * @motto 算法并不可怕, 可怕的是你不敢面对它, 加油！冲击大厂！！！
 * 演示稀疏数组的使用
 * 实现的功能：将一个二维数组转换成稀疏数组   并把他写入文件  读取文件并进行还原操作
 * 目标:把一个二维数组转换成稀疏数组  然后再把稀疏数组还原成二维数组
 */
public class SparseArray {
    private static int row = 11;//代表数组有11行
    private static int col = 11;//代表数组有11列
    private static int[][] array = new int[row][col];//定义一个二维数组
    private static String filePath = "src\\123.txt";
    public static void main(String[] args) {
        //将二维数组的指定位置赋值
        array[1][2] = 1;//1代表黑棋子
        array[2][3] = 2;//2代表蓝棋子
        for (int[] rows :array) {
            for (int values : rows) {
                System.out.print(values + "\t");
            }
            System.out.println();
        }

        int[][] sparseArray = sparseArrayConvert(array);
        //将稀疏数组写入文件123.txt
        output(sparseArray);
        //在这里调用读取文件的的操作 从文件中进行读取 返回值是一个稀疏数组
        int[][] input = input();

        System.out.println("读取文件得到的稀疏数组如下===========");
        for (int[] rows :input) {
            for (int values : rows) {
                System.out.print(values + "\t");
            }
            System.out.println();
        }
//        System.out.println("还原后===");
//        int[][] ints = sparseArrayRestore(sparseArray);
//        for (int[] rows :ints) {
//            for (int values : rows) {
//                System.out.print(values + "\t");
//            }
//            System.out.println();
//        }
    }
    //该方法用于将一个二维数组转换成稀疏数组 返回值是一个稀疏数组
    public static int[][] sparseArrayConvert(int[][] arr){
        int sum = 0;//记录稀疏数组的值的个数
        //遍历二维数组 得到有几颗棋子
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j] != 0){
                    sum++;
                }
            }
        }
        //创建稀疏数组
        int[][] sparseArray = new int[sum+1][3];//稀疏数组永远都是3列
        //对稀疏数组的第一行进行赋值
        sparseArray[0][0] = row;
        sparseArray[0][1] = col;
        sparseArray[0][2] = sum;
        //继续遍历二维数组 对稀疏数组进行赋值操作
        int num = 1;//记录稀疏数组列数自增的变量
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j] != 0){
                    sparseArray[num][0] = i;
                    sparseArray[num][1] = j;
                    sparseArray[num][2] = arr[i][j];
                    num++;
                }
            }
        }
        return sparseArray;
    }

    //该方法将一个稀疏数组还原
    public static int[][] sparseArrayRestore(int[][] sparseArray){
        int rows = 0;
        int cols = 0;
        rows = sparseArray[0][0];
        cols = sparseArray[0][1];
        int[][] ints = new int[rows][cols];
        //遍历稀疏数组 从第二行开始遍历
        for (int i = 1; i < sparseArray.length; i++) {
                ints[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return ints;
    }

    //该方法将一个二维数组保存到文件中
    public static void output(int[][] arr)  {
        //创建一个输出流 用字符输出流 处理流
        BufferedWriter bw = null;
        try {
            bw = new BufferedWriter(new FileWriter(filePath));
            for (int i = 0; i < arr.length; i++) {
                bw.write(arr[i][0] + " " + arr[i][1] + " " + arr[i][2]);
                bw.newLine();//每写一行就换行
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关流 关外层流即可
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static int[][] input(){
        int num = 1;
        int[][] sparseArray = null;
        //使用字符输入流(处理流)读取文件
        BufferedReader br = null;
        try {
            String readLen = "";
            br = new BufferedReader(new FileReader(filePath));
            //先读取第一行 用于创建稀疏数组
            String[] s1 = br.readLine().split(" ");
            sparseArray = new int[Integer.parseInt(s1[2]) + 1][3];
            sparseArray[0][0] = Integer.parseInt(s1[0]);
            sparseArray[0][1] = Integer.parseInt(s1[1]);
            sparseArray[0][2] = Integer.parseInt(s1[2]);
            while((readLen = br.readLine()) != null) {//循环读取 从第二行开始 读取到文件末尾返回null
                String[] s = readLen.split(" ");
                sparseArray[num][0] = Integer.parseInt(s[0]);
                sparseArray[num][1] = Integer.parseInt(s[1]);
                sparseArray[num][2] = Integer.parseInt(s[2]);
                num++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sparseArray;
    }
}