Java-数据结构系列一：稀疏数组与二维数组相互转化（含输入输出流）

本文链接：https://blog.csdn.net/money_yao/article/details/99292350

1.应用场景：

棋盘、地图等二维数组默认值为0，记录了相当多没有意义的数据；当一个数组中大部分元素为同一个值时，可以使用稀疏数组来保存该数组；
稀疏数组的处理方法是：
- 记录数据共几行几列，有多少不同的值，
- 把具有不同值的元素的行列坐标及值记录在一个小规模的数组中，从而缩小程序的规模；
补充一点输入输出流的基础知识：
Java的文件流：
- Java的输入输出流（InputStream，OutputStream）能够操作的是字节码；
- Java的文件流（FileInputStream和FileOutputStream）对文件做读写操作，在输入输出流上加入流过滤器；
  - DataInputStream和DataOutputStream用以读写二进制表达的基本数据类型的数据；

    1 	public static void main(String[] args) {
    2 		System.out.println("File output test");
    3 		byte[] buf=new byte[10];//构建字节数组
    4 		for(int i=0;i<buf.length;i++) {
    5 		    buf[i]=(byte)i;
    6 		}
    7 		try {//接入缓冲过滤器，DataOutputStream,最后落到FileOutputStream文件中
    8 		    DataOutputStream out=new DataOutputStream(
    9 			new BufferedOutputStream(
   10 			    new FileOutputStream("b.dat")));
   11 //在fileOutputStream后面介入缓冲过滤器,Buffer起到缓存的作用，Data起到读写基本数据类型的作用
   12 		int i=1234;
   13 				
   14 		out.writeInt(i);
   15 				
   16 		out.close();
   17 				
   18 	    DataInputStream in=new DataInputStream(
   19 		new BufferedInputStream(
   20 		    new FileInputStream("b.dat")));
   21 	    int j=in.readInt();
   22 	    System.out.println(j);
   23 	} catch (FileNotFoundException e) {
   26 	    e.printStackTrace();
   27 	} catch (IOException e) {
   29 	    e.printStackTrace();
   30 	    }	
   31 	}
   32

处理文本的输入输出用Reader/Writer，Reader/Writer处理Unicode编码的文件，在刘尚建立文本处理

package stream;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;


public class FileRead {
    public static void main(String[] args) {
        System.out.println("File output test");
	try {
	//写文本文件到txt文件
	PrintWriter out=new PrintWriter(
	    new BufferedWriter(	//得到bufferWriter
	        new OutputStreamWriter(//OutputStreamWriter构建stream和writer之间的桥梁，输入是stream，输出是writer
		    new FileOutputStream("writer.txt"))));	//FileOutputStream只能处理字节
	String s="This is an example of writting to text";
	out.write(s);
	out.close();
	System.out.println("Writing to text is over");
			
        //读取文本文件
	BufferedReader in=new BufferedReader(
	    new InputStreamReader(
	        new FileInputStream("H://Shapes/src/shapes/Picture.java"),"utf8"));
	String line;
	while((line=in.readLine())!=null) {
	System.out.println(line);
	}
	in.close();
	} catch (FileNotFoundException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	}	
    }
}

2.java代码实现稀疏数组与二维数组的转换，同时写入/读取文本文件

package sparsearray;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;

//五子棋游戏，将棋盘存储为稀疏数组，同时将稀疏数组转为原始二维数组
public class SparseArray {
	public static void main(String[] args) {
		//创建原始11*11二维数组，0表示为空，1表示黑子，2表示白子
		int chessArr1[][]=new int[11][11];
		chessArr1[1][2]=1;
		chessArr1[2][3]=2;
		chessArr1[3][4]=2;
		chessArr1[5][7]=1;
		System.out.println("输出原始二维数组：");
		for(int[] row:chessArr1) {
			for(int data:row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		
		//将原始的二维数组转换为稀疏数组
		int sum=0;
		for (int i=0;i<11;i++) {
			for(int j=0;j<11;j++) {
				if(chessArr1[i][j] != 0) {
					sum++;
				}
			}
		}
		//创建对应的稀疏数组
		int sparseArr[][]=new int[sum+1][3];
		//给稀疏数组赋值
		sparseArr[0][0]=11;
		sparseArr[0][1]=11;
		sparseArr[0][2]=sum;
		//遍历原始的二维数组，填充sparseArr，用count计数
		int count=0;
		for (int i=0;i<11;i++) {
			for(int j=0;j<11;j++) {
				if(chessArr1[i][j] != 0) {
					count++;
					sparseArr[count][0]=i;
					sparseArr[count][1]=j;
					sparseArr[count][2]=chessArr1[i][j];
				}
			}
		}
		//输出稀疏数组
		System.out.println();
		System.out.println("输出稀疏数组：");
		for(int i=0;i<sparseArr.length;i++) {
			System.out.printf("%d\t%d\t%d\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
		}
		//将稀疏数组写到文件中
		File file=new File("H:\\JavaLearn\\DataStructures\\SparseArr.txt");
		try {
			PrintWriter out=new PrintWriter(
					new BufferedWriter(new OutputStreamWriter(
							new FileOutputStream(file))));
			for(int i=0;i<sparseArr.length;i++) {
				for(int j=0;j<3;j++) {
					out.write(sparseArr[i][j]+"\t");
				}
				out.write("\r\n");
			}	
			out.close();
			System.out.println("Writing to text is over");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e) {
			e.printStackTrace();
		}
		//从文件中读取稀疏数组
		ArrayList<String> arrayList=new ArrayList<>();
		
		try {
			BufferedReader in=new BufferedReader(
					new InputStreamReader(
							new FileInputStream(file)));
			String line;
			while((line=in.readLine())!=null) {
				arrayList.add(line);
			}
			in.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e) {
			e.printStackTrace();
		}
		//对读取的arrayList中存储的字符串进行处理
		int length=arrayList.size();
		int width=arrayList.get(0).split("\t").length;
		int sparseArr1[][]=new int[length][width];
		for(int i=0;i<sparseArr1.length;i++) {
			for(int j=0;j<width;j++) {
				String s=arrayList.get(i).split("\t")[j];
				sparseArr1[i][j]=Integer.parseInt(s);
			}
		}
		System.out.println("输出读取到的稀疏数组：");
		for(int[] row:sparseArr1) {
			for(int data:row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		//将稀疏数组恢复成原始的二维数组
		int rowNum=sparseArr1[0][0];
		int colNum=sparseArr1[0][1];
		int chessArr2[][]=new int[rowNum][colNum];
		
		for(int i=1;i<sparseArr1.length;i++) {
			chessArr2[sparseArr1[i][0]][sparseArr1[i][1]]=sparseArr1[i][2];
		}
		System.out.println("输出复原后的原始二维数组：");
		for(int[] row:chessArr2) {
			for(int data:row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}	
	}
}