一、实际需求

编写的五子棋程序中，有存盘退出和继续上盘的功能。

分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意思的数据，如何在计算机中高效的存储这样的二维数组是一个需要考虑的问题。

二、基本介绍

当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是：

记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

示意图：

三、应用实例

（1）使用稀疏数组，来保留类似前面的二维数组（棋盘，地图等等）

（2）把稀疏数组存盘，并且可以重新恢复原来的二维数组

（3）整体思路分析

（4）代码实现：

将原始的二维数组转成稀疏矩阵，并保存在磁盘上，比如sqc.data
恢复原来的数组时，读取sqc.data进行恢复

package com.atguigu.sparsearray;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class SparseArrayDemo {
	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;
		
		
		//打印原始的二维数组
		System.out.println("原始的二维数组：");
		for(int i=0;i<11;i++){
			for(int j=0;j<11;j++){
				System.out.print(chessArr1[i][j]+"\t");
			}
			System.out.println();
		}
		
		
		//将二维数组转成稀疏数组
		int count=0;
		int [] x=new int [121];
		int [] y=new int [121];
		for(int i=0;i<11;i++){
			for(int j=0;j<11;j++){
				if(chessArr1[i][j]!=0){
					x[count]=i;
					y[count]=j;
					count++;
				}
			}
		}
		int [][] sparseArr=new int [count+1][3];
		sparseArr[0][0]=11;
		sparseArr[0][1]=11;
		sparseArr[0][2]=count;
		for(int i=0;i<count;i++){
			sparseArr[i+1][0]=x[i];
			sparseArr[i+1][1]=y[i];
			sparseArr[i+1][2]=chessArr1[x[i]][y[i]];
		}
		
		
		//打印稀疏数组
		System.out.println("原始的稀疏数组：");
		for(int i=0;i<count+1;i++){
			for(int j=0;j<3;j++){
				System.out.print(sparseArr[i][j]+"\t");
			}
			System.out.println();
		}
		
		
		//将稀疏数组保存到磁盘中的文件
		File file =new File("I:/sqc.data");
		FileOutputStream fos=null;
		DataOutputStream dos=null;
		try {
			fos=new FileOutputStream(file);
			dos=new DataOutputStream(fos);
			for(int i=0;i<count+1;i++){
				for(int j=0;j<3;j++){
					dos.writeInt(sparseArr[i][j]);
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fos!=null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(dos!=null){
				try {
					dos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		
		//从磁盘中的文件读取稀疏数组
		FileInputStream fis=null;
		DataInputStream dis=null;
		try {
			fis=new FileInputStream(file);
			dis=new DataInputStream(fis);
			int [] temp=new int [3*(count+1)];
			for(int i=0;i<3*(count+1);i++){
				temp[i]=dis.readInt();
			}
			int [][] sparseArr1=new int [count+1][3];
			int c=0;
			for(int i=0;i<count+1;i++){
				for(int j=0;j<3;j++){
					sparseArr1[i][j]=temp[c++];
				}
			}
			//打印从磁盘中读取的稀疏数组
			System.out.println("文件中读取的稀疏数组：");
			for(int i=0;i<count+1;i++){
				for(int j=0;j<3;j++){
					System.out.print(sparseArr1[i][j]+"\t");
				}
				System.out.println();
			}
			//将磁盘中读取的稀疏数组转成原始的二维数组
			int [][] chessArr2=new int [sparseArr1[0][0]][sparseArr1[0][1]];
			for(int i=0;i<sparseArr1[0][2];i++){
				chessArr2[sparseArr1[i+1][0]][sparseArr1[i+1][1]]=sparseArr1[i+1][2];
			}
			//打印由稀疏数组转换的二维数组
			System.out.println("文件中读取的原始数组：");
			for(int i=0;i<11;i++){
				for(int j=0;j<11;j++){
					System.out.print(chessArr2[i][j]+"\t");
				}
				System.out.println();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fis!=null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(dis!=null){
				try {
					dis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

效果图：