Java实现稀疏数组以及将稀疏数组存储到硬盘和从硬盘种读取操作

• Java实现稀疏数组
• 原二维数组—>稀疏数组
• 稀疏数组—>原二维数组
• 将稀疏数组保存到硬盘中
• 将稀疏数组读入内存
• 为了扩展思维，练习编程，所以写法不一
• 从上到下看就好，没有对函数进行封装

package zc;
/**
 * Java实现稀疏数组
 * 原二维数组--->稀疏数组
 * 稀疏数组--->原二维数组
 * 将稀疏数组保存到硬盘中
 * 将稀疏数组读入内存
 * 为了扩展思维，练习编程，所以写法不一
 * 从上到下看就好，没有对函数进行封装
 * @param args
 */
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class SparseArray {
	public static void main(String[] args) {
		//创建一个系数数组
		int[][] arr=new int[11][11];
		arr[0][0]=1;
		arr[1][1]=2;
		arr[5][6]=3;
		//输出二维数组
		System.out.println("-----------------二维数组----------------------------");
	
		for(int[] row:arr) {
			for(int data:row) {
				System.out.print(data+"\t");
			}
			System.out.println();
		}
		
		//二维数组转稀疏数组
		int sum=0;
		for(int[] row:arr) {
			for(int data:row) {
				sum=data!=0?sum+1:sum;  //三元运算符
			}
		}
		System.out.println(sum);  //输出不为零的个数
		
		//创建稀疏数组
		int sparseArr[][]=new int[sum+1][3];
		sparseArr[0][0]=arr.length;   //原二维数组的行数
		sparseArr[0][1]=arr[0].length;  //原二维数组的列数
		sparseArr[0][2]=sum;
		
		//遍历二维数组，将不为0的数放入稀疏数组中
		int count=0;
		for(int i=0;i<arr.length;i++) {
			for(int j=0;j<arr[0].length;j++) {
				if(arr[i][j]!=0) {
					sparseArr[++count][0]=i;
					sparseArr[count][1]=j;
					sparseArr[count][2]=arr[i][j];
				}
			}
		}
		
		//打印稀疏数组
		System.out.println("-----------------稀疏数组---------------------------");
		for(int[] row:sparseArr) {
			for(int data:row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		
		//稀疏数组还原成原二维数组
		int [][] arr2;
		arr2=new int[sparseArr[0][0]][sparseArr[0][1]];
		//读取稀疏数组的数据，将其赋值给二维数组
		for(int i=1;i<sparseArr.length;i++) {
				arr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
		}
		
		//打印还原后的二维数组
		System.out.println("-----------------还原后二维数组-------------------");
		for(int[] row:arr2) {
			for(int data:row) {
				System.out.print(data+"\t");
			}
			System.out.println();
		}
		
		//将稀疏数组保存到硬盘上
		File dest=new File("sparesArray.data");
		
		try (BufferedWriter bw=new BufferedWriter(new FileWriter(dest));){
			for(int[] row:sparseArr) {
				for(int data:row) {
					bw.write(data+"\t");
				}
				bw.write("\n");
				bw.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		//从硬盘读取稀疏数组，并进行恢复
		//获取硬盘中稀疏数组的行数，并将其存储到一个list中
		File src=new File("sparesArray.data");
		BufferedReader br=null;
		List<Integer> list=new ArrayList<>();
		try {
			br=new BufferedReader(new FileReader(src));
			String line;
			while((line=br.readLine())!=null) {
				   String[] str=line.split("\t");
				   for(int i=0;i<str.length;i++) {
					   list.add(Integer.parseInt(str[i]));
				   }
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(br!=null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		//打印稀疏数组行数
		System.out.println("稀疏数组的行数为：  "+list.get(2)+1);   //第三个元素代表不为0的元素有多少个，+1代表稀疏数组的行数
		
		
		//从硬盘读取稀疏数组到内存种的方法一：由于还要进行读硬盘操作，效率较低
		//创建稀疏数组
		/*int sparseArr2[][]=new int[list.get(2)+1][3];
		File src2=new File("sparesArray.data");
		BufferedReader br2=null;
		List<Integer> list2=new ArrayList<>();
		int row=0;
		try {
			br=new BufferedReader(new FileReader(src));
			String line;
			while((line=br.readLine())!=null) {
				   String[] str=line.split("\t");
				   for(int i=0;i<str.length;i++) {
					   sparseArr2[row][i]=(Integer.parseInt(str[i]));
				   }
				   row++;
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(br!=null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		//打印稀疏数组
		System.out.println("-----------------稀疏数组---------------------------");
		for(int[] row2:sparseArr2) {
			for(int data:row2) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}*/ 
		
		
		//从硬盘读取稀疏数组到内存种的方法二：直接对之前的list进行操作
		//创建稀疏数组
		int sparseArr2[][]=new int[list.get(2)+1][3];
		int j=0;
		for(int i=0;i<list.size();i=i+3) {
			sparseArr2[j][0]=list.get(i);
			sparseArr2[j][1]=list.get(i+1);
			sparseArr2[j][2]=list.get(i+2);
			j++;
		}
		
		System.out.println("-----------------从硬盘种读取的稀疏数组---------------------------");
		for(int[] row2:sparseArr2) {
			for(int data:row2) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
	}
}