关于稀疏数组的学习和实现

菜鸟学习，记录自己的学习心的。
稀疏数组主要就是将大量无用的数据丢弃掉，保存有用的数据，将有用的数据保存到一个二维数组中。

思路如下

1. 首先我们需要获取需要保存数据的二维数组的行数、列数、还有就是非0的值，获得之后将数据保存到sparseArray[][]数组中。
2. 记录非0数据的坐标信息和具体值

代码如下

public static void main(String[] args) throws IOException {
		int[][] sparseArray = new int[33][33];
		Random random = new Random();
		for (int i = 0; i < 30; i++) {
			sparseArray[random.nextInt(33)][random.nextInt(33)] = random.nextInt(2) + 1;
		}
		printSZ(sparseArray, "原始二维数组");
		int[][] xS = xS(sparseArray, getSum(sparseArray));
		printSZ(xS, "稀疏之后的二维数组");
		printSZ(zhuanHuanXiShu(xS), "稀疏转换成二维数组");
		if (cunShuZu(xS)) {
			System.out.println("本地保存成功");
		} else {
			System.out.println("数据异常");
		}
		printSZ(duQu(), "本地读取数据");
	}

定义方法遍历二维数组

	/**
	 * @param 需要遍历的二维数组
	 * @param 打印前需要输入的语句
	 */
	public static void printSZ(int[][] arrays, String title) {
		System.out.println(title);
		for (int[] is : arrays) {
			for (int is2 : is) {
				System.out.printf("%3d", is2);
			}
			System.out.println();
		}
	}

定义方法用来计算有多少非零的数据

	/**
	 * 	计算二维数组中有多少非0的数据
	 * 
	 * @param 传入需要保存的二维数组
	 * @return 返回非0的数据总和
	 */
	public static int getSum(int[][] arrays) {
		int sum = 0;
		for (int i = 0; i < arrays.length; i++) {
			for (int j = 0; j < arrays.length; j++) {
				if (arrays[i][j] != 0) {
					sum++;
				}
			}
		}
		return sum;
	}

定义方法将最初的数据进行统计

	/**
	 * 将之前的二维数组进行稀疏，并用新的数组保存之前二维数组的信息
	 * 
	 * @param 需要保存的二维数组信息
	 * @param 有多少个需要保存的数据
	 * @return 保存之前二维数组的信息
	 */
	public static int[][] xS(int[][] arrays, int sum) {
		int[][] sparseArray = new int[sum + 1][3];
		sparseArray[0][0] = arrays[0].length;
		sparseArray[0][1] = arrays[1].length;
		sparseArray[0][2] = sum;
		int temp = 1;
		for (int i = 0; i < arrays.length; i++) {
			for (int j = 0; j < arrays[i].length; j++) {
				if (arrays[i][j] != 0) {
					sparseArray[temp][0] = i;
					sparseArray[temp][1] = j;
					sparseArray[temp][2] = arrays[i][j];
					temp++;
				}
			}
		}
		return sparseArray;
	}

定义方法将稀疏后的二维数组数据转换成二维数组

	/**
	 * 	将稀疏之后的数据转换成二维数组
	 * 
	 * @param 稀疏之后的数组
	 * @return 还原之后的二维数组
	 */
	public static int[][] zhuanHuanXiShu(int[][] arrays) {
		int[][] sparseArray = new int[arrays[0][0]][arrays[0][1]];
		for (int i = 1; i < arrays.length; i++) {
			sparseArray[arrays[i][0]][arrays[i][1]] = arrays[i][2];
		}
		return sparseArray;
	}

定义方法将数据本地化存取

public static int[][] duQu() {
		int[][] sparseArray = null;
		InputStream inputStream = null;
		try {
			inputStream = new FileInputStream(new File("asd.data"));
			byte[] bytes = new byte[1024];
			int tem = 0;
			StringBuffer stringBuffer = new StringBuffer();
			String string = "";
			while ((tem = inputStream.read(bytes)) != -1) {
				string = new String(bytes, 0, tem);
				stringBuffer.append(string);
			}
			String[] split = string.split(",");
			sparseArray = new int[split.length / 3][3];
			int number = 0;
			for (int i = 0; i < split.length; i++) {
				int number2 = i % 3;
				if (i != 0 && number2 == 0) {
					number++;
				}
				sparseArray[number][number2] = Integer.parseInt(split[i]);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			inputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return sparseArray;
	}

	/**
	 * 将文件保存到本地
	 * 
	 * @param 需要保存的数据源
	 * @return 是否成功
	 * @throws IOException
	 */
	public static boolean cunShuZu(int[][] arrays) throws IOException {
		StringBuffer stringBuffer = new StringBuffer();
		for (int i = 0; i < arrays.length; i++) {
			for (int j = 0; j < arrays[i].length; j++) {
				stringBuffer.append(arrays[i][j]).append(",");
			}
		}
		if (stringBuffer.length() == 0) {
			return false;
		}
		File file = new File("asd.data");
		if (!file.exists()) {
			file.createNewFile();
		}
		OutputStream outputStream = new FileOutputStream(file);
		String string = stringBuffer.toString();
		byte[] bytes = string.getBytes();
		outputStream.write(bytes, 0, bytes.length);
		outputStream.close();
		return true;
	}

本文地址：https://blog.csdn.net/MsyLaoLi/article/details/107597972