稀疏矩阵的实现：棋盘的存个档读档

利用稀疏矩阵压缩存储棋盘：二维数组-》稀疏矩阵-》文件

package hanshunping.sparsearray;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 游戏存档 二维数组->稀疏矩阵->文件
 * @author Administrator
 * @date 2019/6/10/9:31
 */

public class StoreGame {

    public static void main(String[] args) {

        //定义一个二维棋盘
        int[][] chessArray = new int[11][11] ;
        //设置棋子 1/黑棋，2/白棋
        chessArray[2][3] = 1;
        chessArray[3][4] = 2;
        chessArray[4][5] = 3;

        StoreGame obj = new StoreGame();
        //1获得棋子总数
        int sum = obj.count(chessArray);
        //2压缩成稀疏矩阵
        int[][] sparseArray= obj.toSparseArray(chessArray,sum);
        //3打印稀疏矩阵
        obj.display(sparseArray);
        //4.存入文件
        obj.write2file(sparseArray);

    }

    /**
     * 压缩成稀疏矩阵
     * @param chessArray
     * @return 稀疏矩阵
     */
    public int[][] toSparseArray(int[][] chessArray,int sum){

        //转换成稀疏矩阵
        System.out.println("变换中。。。。\n");
        //定义系数矩阵 一共有记录总数+1行
        int[][] sparseArray = new int[sum+1][3];
        //稀疏矩阵的第一行
        sparseArray[0][1] = sparseArray[0][0] = chessArray.length;
        sparseArray[0][2] = sum;
        //其余行,遍历第一个棋盘，找到值！=0的数据
        int count = 0;
        for (int i=0;i<chessArray.length;i++){
            for (int j=0;j<chessArray.length;j++){
                if (chessArray[i][j] != 0){
                    //记录是第几个数字，第 i 个数字在 i+1行
                    count = count + 1;
                    //所在行
                    sparseArray[count][0] = i;
                    //所在列
                    sparseArray[count][1] = j;
                    //值
                    sparseArray[count][2] = chessArray[i][j];
                }//if
            }//for2
        }//for1
        return sparseArray;
    }

    /**
     * 计算棋子总数
     * @param chessArray
     * @return 棋子总数
     */
    public int count(int[][] chessArray){
        //棋子总数
        int sum = 0;
        for (int[] row : chessArray) {
            for (int val : row) {
                System.out.print(val+"\t");
                if (val != 0){
                    sum = sum + 1;
                }
            }
            System.out.println();
        }
        return sum;
    }

    /**
     * 打印稀疏矩阵
     * @param sparseArray
     */
    public void display(int[][] sparseArray){
        System.out.println("压缩后的稀疏矩阵：");
        for (int i=0;i<sparseArray.length;i++) {
            System.out.println(sparseArray[i][0]+"\t"+sparseArray[i][1]+"\t"+sparseArray[i][2]);
        }
    }

    public void write2file(int[][] sparseArray){
        //稀疏矩阵写入文件
        //存放数组数据的文件
        File file = new File("data.txt");
        //文件写入流
        FileWriter out = null;
        try {
            out = new FileWriter(file);
            for(int i=0;i<sparseArray.length;i++){
                for(int j=0;j<sparseArray[0].length;j++){
                    out.write(sparseArray[i][j]+"\t");
                }
                out.write("\r\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //将数组中的数据写入到文件中。每行各数据之间TAB间隔
    }
}

读档：文件->稀疏矩阵->二维数组

package hanshunping.sparsearray;

import java.io.*;

/**
 * 文件->稀疏矩阵->二维数组
 * @author Administrator
 * @date 2019/6/10/9:55
 */

public class ReadGame {
    public static void main(String[] args) {
        ReadGame obj = new ReadGame();
        File file = new File("data.txt");
        //读取文件
        int[][] spareArray = obj.readFile(file,3);
        obj.toChessArry(spareArray);
    }

    /**
     * 从文件中读取稀疏数组，并转成int类型
     * @param file
     * @param sum
     */
    public int[][] readFile(File file, int sum){
        //读取文件中的稀疏矩阵
        //定义系数矩阵 一共有记录总数+1行
        int[][] sparseArray = new int[sum+1][3];

        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
            String str = bufferedReader.readLine();
            int count2=0;
            while (str != null && str !=""){
                //System.out.println(str);
                String[] rows = str.split("\t");
                for (int i=0;i<rows.length;i++){
                   // System.out.println(Integer.parseInt(rows[i]));
                    sparseArray[count2][i] = Integer.parseInt(rows[i]);
                }
                ++count2;
                str = bufferedReader.readLine();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sparseArray;
    }

    /**
     * 打印稀疏数组
     * @param sparseArray
     */
    public void display(int[][] sparseArray){
        System.out.println("重文件读取的稀疏矩阵：");
        for (int i=0;i<sparseArray.length;i++) {
            System.out.println(sparseArray[i][0]+"\t"+sparseArray[i][1]+"\t"+sparseArray[i][2]);
        }
    }

    /**
     * 由系数矩阵编程二维数组
     * @param sparseArray
     * @return
     */
    public int[][] toChessArry(int[][] sparseArray){
        //由稀疏矩阵转换成棋盘
        //根据稀疏矩阵的第一行创建棋盘
        int[][] chessArray = new int[ sparseArray[0][0] ] [ sparseArray[0][1] ];
        //遍历稀疏矩阵中的数据,从第二行开始
        for (int i=1;i<sparseArray.length;i++) {
            chessArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

        System.out.println("恢复后的棋盘：\n");
        for (int[] ints : chessArray) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println("\n");
        }
        return chessArray;
    }
  
}