1. Demanda real
- Existe uma função de
存盘退出soma no programa Gobang escrito续上盘.
- Análise do problema:
Como muitos valores da matriz bidimensional são valores padrão0, muitos dados sem sentido são registrados .-> Matriz esparsa.
2. Matriz esparsa
2.1 Introdução básica
Quando a maioria dos elementos em uma matriz são ０ou são 同一个值matrizes, você pode usar uma matriz esparsa para salvar a matriz.
2.2 O método de processamento da matriz esparsa é:
- A matriz de registro tem um total de várias linhas e colunas, e quantos valores diferentes existem
- Registre as classificações e valores dos elementos com valores diferentes em uma pequena matriz, reduzindo assim o tamanho do programa
2.3 Exemplos
A matriz esparsa convertida, a primeira linha registra o número de linhas, o número de colunas e a quantidade de dados que não é 0.
Cada linha subsequente registra o valor diferente de zero e seu valor.
3. Exemplos de aplicação
- Use matrizes esparsas para reter matrizes bidimensionais semelhantes às anteriores (tabuleiros de damas, mapas, etc.)
- Salve a matriz esparsa e restaure o número da matriz bidimensional original
- Análise de pensamento geral
3.1 Diagrama
3.2 A ideia de converter uma matriz bidimensional em uma matriz esparsa
- Percorra a matriz bidimensional original para obter o número de soma de dados válida
- De acordo com a soma, pode-se criar uma matriz esparsa sparseArr int [sum + 1] [3]
- Armazene os dados válidos da matriz bidimensional na matriz esparsa
3.3 A ideia de converter uma matriz esparsa em uma matriz bidimensional original
- Primeiro leia a primeira linha da matriz esparsa e crie a matriz bidimensional original com base nos dados da primeira linha, como chessArr2 = int acima [11] [11]
- Em seguida, leia os dados nas últimas linhas da matriz esparsa e atribua-os à matriz bidimensional original.
4. Implementação de código
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();
}
}
}
O resultado da corrida é:
