稀疏数组与普通数组的转化与，以及将数组存进文件与从文件中读取出来

稀疏数组

稀疏数组的出现有利于一些特殊场景，在一些重复数组比较多的情况下他避免了空间的浪费，只将有用的数据保存起来。

1.只是稀疏数组与普通数组的转化

	private static void test1() {
		// 先建一个原始数组11行11列
		int[][] chessArr = new int[11][11];
		// 存入两个数据
		chessArr[3][4] = 1;
		chessArr[2][5] = 2;
		// 声明变量
		int sum = 0;
		// 输出原始数组
		for (int[] row : chessArr) {
			for (int data : row) {
				System.out.print(data + " ");
			}
			System.out.println();
		}
		//找到数组类所有非0的数字的个数
		for (int[] row : chessArr) {
			for (int data : row) {
				if (data != 0) {
					sum++;
				}
			}
		}
		System.out.println("sum="+sum);
		//创建稀疏数组
		//行数为sum+1，列数为3
		//第一列存原数组的行号，第二列存原数组的列号，第三列存原数组的数值
		//稀疏数组第一行为特例，分别存的是原数组的总行数与总列数与总有效数字的个数。
		int[][] arr = new int[sum + 1][3];
		arr[0][0] = 11;
		arr[0][1] = 11;
		arr[0][2] = sum;
		//声明一个计数变量
		int number = 0;
		//将原数组里面的有效数值（非0）的行号、列号、数值存进稀疏数组里
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr[i].length; j++) {
				if (chessArr[i][j] != 0) {
					//先加1，后加值，意思是从第二行开始存数据
					number++;
					//行号
					arr[number][0] = i;
					//列号
					arr[number][1] = j;
					//数值
					arr[number][2] = chessArr[i][j];
				}
			}
		}
		//打印这个稀疏数组
		for (int[] row : arr) {
			for (int data : row) {
				if (data > 9) {
					System.out.print(data + " ");
				} else {
					System.out.print(data + "  ");
				}
			}
			System.out.println();
		}
		//由稀疏数组转为原数组
		//先获取原数组的长度与宽度
		int[][] arr1 = new int[arr[0][0]][arr[0][1]];
			for (int i = 1; i < arr.length; i++) {
					arr1[arr[i][0]][arr[i][1]] = arr[i][2];
			}
			//打印原来的数组
		for (int[] row : arr1) {
			for (int data : row) {
				System.out.print(data + " ");
			}
			System.out.println();
		}

	}

2.稀疏数组与普通数组的转化与，以及存进文件与从文件中读取出来（附加了对文件的操作）

package com.etime03;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test01 {

	public static void main(String[] args) {
		// 从文件中读取稀疏数组并转化为正常二维数组。
		test2();
		// 将普通数组转化为稀疏数组存入文件中
		// test1();
	}

	private static void test1() {
		// 先建一个原始数组11行11列
		int[][] chessArr = new int[11][11];
		// 存入两个数据
		chessArr[3][4] = 1;
		chessArr[2][5] = 2;
		// 声明变量
		int sum = 0;
		// 输出原始数组
		for (int[] row : chessArr) {
			for (int data : row) {
				System.out.print(data + " ");
			}
			System.out.println();
		}
		// 找到数组类所有非0的数字的个数
		for (int[] row : chessArr) {
			for (int data : row) {
				if (data != 0) {
					sum++;
				}
			}
		}
		System.out.println("sum=" + sum);
		// 创建稀疏数组
		// 行数为sum+1，列数为3
		// 第一列存原数组的行号，第二列存原数组的列号，第三列存原数组的数值
		// 稀疏数组第一行为特例，分别存的是原数组的总行数与总列数与总有效数字的个数。
		int[][] arr = new int[sum + 1][3];
		arr[0][0] = 11;
		arr[0][1] = 11;
		arr[0][2] = sum;
		// 声明一个计数变量
		int number = 0;
		// 将原数组里面的有效数值（非0）的行号、列号、数值存进稀疏数组里
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr[i].length; j++) {
				if (chessArr[i][j] != 0) {
					// 先加1，后加值，意思是从第二行开始存数据
					number++;
					// 行号
					arr[number][0] = i;
					// 列号
					arr[number][1] = j;
					// 数值
					arr[number][2] = chessArr[i][j];
				}
			}
		}
		// 打印这个稀疏数组
		for (int[] row : arr) {
			for (int data : row) {
				if (data > 9) {
					System.out.print(data + " ");
				} else {
					System.out.print(data + "  ");
				}
			}
			System.out.println();
		}
		// 将稀疏数组存放在文件里面
		BufferedWriter bufferedWriter = null;
		try {
			bufferedWriter = new BufferedWriter(new FileWriter("D:\\arr.txt"));
			for (int[] row : arr) {
				for (int i = 0; i < row.length; i++) {
					bufferedWriter.write(String.valueOf(row[i]) + " ");
				}
				bufferedWriter.newLine();
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (bufferedWriter != null) {
				try {
					bufferedWriter.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			bufferedWriter = null;
		}
	}

	private static void test2() {

		// 将稀疏数组从文件中取出来
		BufferedReader bufferedReader = null;
		BufferedReader bufferedReader1 = null;
		try {
			bufferedReader = new BufferedReader(new FileReader("D:\\arr.txt"));
			String line;
			int j = 0;
			// 计算有多少行
			while ((line = bufferedReader.readLine()) != null) {
				j++;
			}
			bufferedReader1 = new BufferedReader(new FileReader("D:\\arr.txt"));
			// 先一行行的读出来，在用split利用空格来劈开
			int[][] arr = new int[j][3];
			// 声明用来对行数与列数的计数变量
			int number1 = 0;
			int number2 = 0;
			while ((line = bufferedReader1.readLine()) != null) {
				String[] split = line.split(" ");
				for (String row : split) {
					// 将被劈开的字符串类型的数组挨着传入一个int类型的数组里面
					arr[number1][number2] = Integer.parseInt(row);
					number2++;
				}
				// 清空每列的数值让他保持0，1，2
				number2 = 0;
				// 每次大循环增加他的行数
				number1++;
			}
			// 由稀疏数组转为原数组
			// 先获取原数组的长度与宽度
			int[][] arr1 = new int[arr[0][0]][arr[0][1]];
			for (int i = 1; i < arr.length; i++) {
				arr1[arr[i][0]][arr[i][1]] = arr[i][2];
			}
			// 打印原来的数组
			for (int[] row : arr1) {
				for (int data : row) {
					System.out.print(data + " ");
				}
				System.out.println();
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (bufferedReader != null) {
				try {
					bufferedReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			bufferedReader = null;
			if (bufferedReader1 != null) {
				try {
					bufferedReader1.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			bufferedReader1 = null;
		}

	}

}