1. 实际需求
- 编写的五子棋程序中，有
存盘退出和续上盘的功能。
- 分析问题：
因为该二维数组的很多值是默认值0, 因此记录了很多没有意义的数据.->稀疏数组。
2. 稀疏数组
2.1 基本介绍
当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
2.2 稀疏数组的处理方法是:
- 记录数组一共有几行几列，有多少个不同的值
- 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
2.3 举例说明
转化后的稀疏数组，第一行记录行数、列数以及不为0的数据量。
后面每一行分别记录非0值的行列及其值。
3. 应用实例
- 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
- 把稀疏数组存盘，并且可以从新恢复原来的二维数组数
- 整体思路分析
3.1 图解
3.2 二维数组 转 稀疏数组的思路
- 遍历原始的二维数组，得到有效数据的个数 sum
- 根据sum 就可以创建稀疏数组 sparseArr int[sum + 1] [3]
- 将二维数组的有效数据存入到稀疏数组
3.3 稀疏数组转原始的二维数组的思路
- 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]
- 再读取稀疏数组后几行的数据，并赋给原始的二维数组即可
4. 代码实现
package sparseArray;
import java.io.*;
import java.util.Arrays;
public class SparseArray {
public static void main(String[] args) throws IOException {
// 创建原始二维数组 11*11
// 0表示没有棋子 1表示黑子 2表示蓝子
int[][] chessArr1 = new int[11][11];
chessArr1[1][2] = 1;
chessArr1[2][3] = 2;
// 输出原始的二维数组
System.out.println("原始的二维数组为：");
for (int[] rows : chessArr1) {
for (int data : rows) {
System.out.printf("%d\t", data);
}
System.out.println();
}
// 二维数组转换为稀疏数组
// 1. 先遍历二维数组，得到非0数据的个数
int sum = 0;
for (int i = 0; i < chessArr1.length; i++) {
for (int j = 0; j < chessArr1[0].length; j++) {
if (chessArr1[i][j] != 0) sum++;
}
}
// System.out.printf("非零元素的个数为：%d",sum);
// 2. 创建对应稀疏数组
int[][] sparseArr = new int[sum + 1][3];
// 3. 给稀疏数组赋值：第一行存储原始数据行列数以及非零元素个数，后面每行存每一个非零元素
// 3.1 给第一行赋值
sparseArr[0][0] = chessArr1.length;
sparseArr[0][1] = chessArr1[0].length;
sparseArr[0][2] = sum;
// 3.2 遍历二维数组，将二维数组的非零元素存放到洗漱数组中
int count = 0; // count用于记录是第几个非零数据
for (int i = 0; i < chessArr1.length; i++) {
for (int j = 0; j < chessArr1[0].length; j++) {
if (chessArr1[i][j] != 0) {
++count;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = chessArr1[i][j];
}
}
}
// 输出得到的稀疏数组
System.out.println("得到的稀疏数组为：");
String textStr = "";
for (int[] rows : sparseArr) {
for (int data : rows) {
System.out.printf("%d\t", data);
textStr = textStr + data + " ";
}
textStr += "\n";
System.out.println();
}
// 4 将稀疏数组恢复成原始的二维数组
// 4.1 读取第一行，根据第一行数据创建原始二维数组
int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
// 4.2 读取稀疏数组后几行数据，赋值给原数组
for (int i = 1; i < sparseArr.length; i++) {
chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
// 输出恢复后的二维数组
System.out.println("恢复后的二维数组为：");
for (int[] rows : chessArr2) {
for (int data : rows) {
System.out.printf("%d\t", data);
}
System.out.println();
}
System.out.println("要存入文件的内容为：");
System.out.println(textStr);
// 5. 将系数矩阵写到map.data
saveFile(textStr, "map.data");
String fileContent = readFile("map.data");
System.out.println("通过文件读取出来的内容为：");
System.out.println(fileContent);
}
/**
* 读取文件
* @param filePath 文件路径
* @return 文件内容
* @throws IOException
*/
public static String readFile(String filePath) throws IOException {
File file = new File(filePath);
// 如果文件不存在则创建文件
if (!file.exists()) {
file.createNewFile();
}
InputStream inputStream = new FileInputStream(file);
// 这里定义了数组的长度是1024个字节，如果文件超出这字节，就会溢出，结果就是读不到1024字节以后的东西
byte[] bs = new byte[1024];
// 这里len获得的是文件中内容的长度
int len = inputStream.read(bs);
inputStream.close();
return new String(bs);
}
/**
* 写文件
* @param content 内容
* @param filePath 路径
*/
public static void saveFile(String content, String filePath) {
File file = new File(filePath);
OutputStream outputStream = null;
if (!file.exists()) {
try {
// 如果文件找不到，就new一个
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
try {
// 定义输出流，写入文件的流
outputStream = new FileOutputStream(file);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
// 定义将要写入文件的数据
String string = content;
// 把string转换成byte型的，并存放在数组中
byte[] bs = string.getBytes();
try {
// 写入bs中的数据到file中
outputStream.write(bs);
} catch (IOException e) {
e.printStackTrace();
}
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果为：
