Java 数组与稀疏数组直接的转化
写了一个demo,实现效果:
- 数组=> 稀疏数组=>文件
- 文件=>稀疏数组=>数组
控制台输出
生成的data文件
/**
* 稀疏数组 : 减少空间,提高效率
*/
public class testArray {
public static void main(String[] args) throws IOException {
int[][] oldArr = getOldArr(); // 声明原始数组,弄一个示例数据
int count = getCount(oldArr); // 获取原始数组的有效数字总数
int[][] buildArray = buildArray(count, oldArr); // 构建稀疏数组
System.out.println("--------原始数组--------");
print(oldArr); // 打印原数组
System.out.println("--------稀疏数组--------");
print(buildArray); // 打印稀疏数组
int[][] oldArray = getOldArray(buildArray); // 再把稀疏数组转换为原始数组
System.out.println("--------稀疏数组-转-原始数组------------");
print(oldArray);
saveFile(buildArray,"C:\\Users\\l\\Desktop\\test"); // 把稀疏数组保存到data文件
int[][] ints = readFile("C:\\Users\\l\\Desktop\\test\\map.data"); // 读取data文件
System.out.println("打印从文件读取转化后的稀疏数组");
print(ints);
}
// 稀疏数组转换为原始数组
public static int[][] getOldArray(int newArr[][]){
int oldArr[][] = new int[newArr[0][0]][newArr[0][1]];
for (int i = 1; i < newArr.length; i++) {
int row = newArr[i][0];
int col = newArr[i][1];
int value = newArr[i][2];
oldArr[row][col] = value;
}
return oldArr;
}
// 打印
public static void print(int[][] arr){
for (int[] ints : arr) {
for (int i : ints) {
System.out.print(i+"\t");
}
System.out.println();
}
}
/**
* 构建稀疏数组
* @param count
* @param oldArr
* @return
*/
static int[][] buildArray(int count,int[][] oldArr){
int [][] newArr = new int[count+1][3]; //稀疏数组行数 旧数组有效数字+1 ,列固定3行
// 构建稀疏数组第一行
newArr[0][0] = 11; //稀疏数组第一行第一列就是原数组的总行数
newArr[0][1] = 11; //稀疏数组第一行第二列就是原数组的总列数
newArr[0][2] = count; // //稀疏数组第一行第三列就是原始数组的有效数字总数量
int num = 0; //
for (int i = 0; i < oldArr.length; i++) { // 遍历行
for (int j = 0; j < oldArr[i].length; j++) { // 遍历列
if (oldArr[i][j]!=0){ // 如果当前遍历的数是有效数字
num++; // 每走到这儿,稀疏数组就会增加一行
newArr[num][0] = i; // 稀疏数组的第一列:当前有效数字所在的行
newArr[num][1] = j; // 稀疏数组的第二列:当前有效数字所在的列
newArr[num][2] = oldArr[i][j]; // 稀疏数组的第二列:当前有效数字的值
}
}
}
return newArr;
}
// 构建一个测试的二维数组数据
static int[][] getOldArr(){
int [][] arr = new int[11][11];
arr[1][2] = 1;
arr[2][3] = 2;
arr[4][6] = 10;
return arr;
}
// 获取原始数组的有效数字总数
static int getCount(int[][] oldArr){
int count = 0;
for (int[] ints : oldArr) {
for (int i : ints) {
if (i!=0){
count++;
}
}
}
return count;
}
public static boolean saveFile(int[][] newArr,String filePath) throws IOException {
String fileName = "map.data";
filePath = filePath+"/" +fileName;
File file = new File(filePath);
if (file.exists()&&file.isFile()){
file.delete();
}
FileOutputStream stream = new FileOutputStream(filePath);
for (int[] ints : newArr) {
for (int i : ints) {
String line = String.valueOf(i) + "\t";
byte[] bytes = line.getBytes();
stream.write(bytes);
}
stream.write("\n".getBytes());
}
stream.close();
return false;
}
/**
* 读取data文件,转化为稀疏数组
* @param filePath
* @return
* @throws IOException
*/
public static int[][] readFile(String filePath) throws IOException {
File file = new File(filePath);
if (!file.exists()){
throw new FileNotFoundException("文件不存在!");
}
FileInputStream stream = new FileInputStream(file);
int read = 0;
String var = "";
int row = 0; // 表名数组的行
int col = 0;// 表名数组的列
ArrayList<String> list = new ArrayList<>();
while ((read=stream.read())!=-1){ // 读到-1,就没有了
String value = String.valueOf((char) read);
if (!value.equals("\n")){ // 只要不读到换行符就拼接字符串
var += value;
}
if (value.equals("\n")) { // 如果读到换行,表明读完一行
row++;
list.add(var); // 把数据存到集合
var = "";
}
if (value.equals("\t")){ // 如果读到制表符,表明读完一列
col++;
}
}
stream.close();
int [][] newArr = new int[row][col];
for (int i = 0; i < list.size(); i++) {
String line = list.get(i);
String[] split = line.split("\t");
// 字符串数组转化为int类型数组
// 方式1
// 使用stream流方式
int[] splitArr = Arrays.stream(split).mapToInt(Integer::parseInt).toArray();
/*
// 方式2
// 循环转化
int [] splitArr = new int[split.length];
for (int j = 0; j < split.length; j++) {
arr[j] = Integer.parseInt(split[j]);
}*/
newArr[i] = splitArr;
}
return newArr;
}
}