<center>数组的应用总结</center>
<center>1.Arrays类</center>
1. Arrays类里面包含许多应用于数组的方法，它们都是人写的用于实现某些功能,当然你也可以自己写。
在IDEA中可以 Ctrl+点击Arrays 查看里面的源码。
2. Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接用类名进行调用，而“不用”使用对象来调用(注意：是“不用“而不是”不能“)。
3. 查看JDK帮助文档
JDK帮助文档 中有Java各种类包含的方法的使用方法，其中就包括Arrays类里面的各种方法的使用
下图为JDK1.8帮助文档
下面的地址为其官方在线查找地址，目前JDK帮助文档没有出中文版，但是网上可以下载其破解的中文版
4. 数组的工具类 java.util.Arrays 在使用的其中的时候要导入这个类
import java.util.Arrays;
下面是一些具体的应用
package array;
import java.util.Arrays; //首先导入Arrays这个类
public class Excercise9 {
//Arrays工具类
public static void main(String[] args) {
int[] a ={15,5,4,8,6,4};
System.out.println(Arrays.toString(a));//输出这个数组
Arrays.sort(a); //对数组进行升序排序
System.out.println(Arrays.toString(a));
Arrays.fill(a,2); //对数组进行填充
System.out.println(Arrays.toString(a));
Arrays.fill(a,2,4,12); //下标2-4之间用12填充
System.out.println(Arrays.toString(a));
}
}
<center>2.冒泡排序</center>
1. 冒泡排序是一种最为出名的排序算法之一(总共有八大排序)
其代码还是相当简单的，两层循环，外层冒泡轮数，里层依此比较（江湖中，人人皆知）
举例如下图所示:
把{1，2，3，4，5} 排序为{5，4，3，2，1}
其原理是外层每一轮循环依次比较把最小的值传递到最右边，一轮循环下来排好一个数。因此下一轮循环少比较一个数，一直传递下去直到最后的结果。
如果要给某个数组排序，那么其外层最多要循环（array.length-1）次 ，内层每轮最多比较循环（array.length-1-i）次
其中，i 为外层循环 0 <= i <（array.length-1）
2. 算法的优化
优化的方法有多种，这里介绍一种
先在外层轮数定义一个boolean变量为false,再在里层循环里赋值为true,最后判断变量值有没有变化，若没有变化为还是为false则用
break语句打断循环。
3. 程序如下
package array;
public class Exercise8 {
//冒泡排序
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
sort(a);
}
public static void sort(int[] array){
int temp = 0; //定义一个临时变量
for (int i = 0; i < array.length-1; i++) { //外层循环 最多的循环轮数： array.length-1
boolean flag = false; //算法优化
for (int j = 0; j < array.length-1-i; j++) { //里层循环 每一轮外层循环后少一次比较
if (array[j+1] > array[j]){ //按从大到小排列，相邻两个值进行比较，第一轮循环把最小的数传到最后面 //这里注意array[j]和array[j+1]数组溢出问题
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true; //如果没有走这个里循环，说明flag一直为false
}
}
if (flag = false ) {
break;
}
}
for (int x : array) {
System.out.print(x);
}
}
}
<center>3.稀疏数组</center>
1. 应用稀疏数组的地方：比如在编写五子棋游戏中，其中二维数组的很多值默认值为0，因此记录了很多没有意义的数据
2. 稀疏数组：当一二维数组中大部分元素是零，或者为同一值的时候，可以用稀疏数组来保存该数组。
3. 处理方式： 先记录原始数组有几行几列，有多少个不同值。然后把不同值元素的行，列，值记录在一个小规模数组中，从而缩小程序的规模
原始数组
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
稀疏数组
| 行（row） | 列(col) | 值(value) | |
|---|---|---|---|
| [0] | 6 | 7 | 8 |
| [1] | 0 | 3 | 22 |
| [2] | 0 | 6 | 15 |
| [3] | 1 | 1 | 11 |
| [4] | 1 | 5 | 17 |
| [5] | 2 | 3 | -6 |
| [6] | 3 | 5 | 39 |
| [7] | 4 | 0 | 91 |
| [8] | 5 | 2 | 28 |
稀疏数组的格式：
行数：原始数组中不同值的个数+1
列数： 3列
第1行：表示原始数组有几行几列几个不同值
程序如下：
package practice;
public class Practice7 {
//稀疏数组练习2.0
public static void main(String[] args) {
//输出一个原始数组 array1
int[][] array1 = new int[6][7];
array1[0][3] = 22;
array1[0][6] = 15;
array1[1][1] = 11;
array1[1][5] = 17;
array1[2][3] = -6;
array1[3][5] = 39;
array1[4][0] = 91;
array1[5][2] = 28;
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
//把原始数组array1==>稀疏数组array2
// 第一步 计算非零值的个数
int sum = 0; //定义原始数组array1中非零值的个数sum
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0) {
sum++;
}
}
}
System.out.println("非零值的个数sum:"+sum);
//第二步 定义一个稀疏数组array2
int[][] array2 =new int[sum+1][3]; //稀疏数组行数；sum+1, 列数；3
array2[0][0] = 6; //给稀疏数组第一行赋值
array2[0][1] = 7;
array2[0][2] = sum;
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
count++; //给稀疏数组每一行排值
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
}
System.out.println("=================================================================");
//把稀疏数组array2==>转换成原始数组array3
int[][] array3 =new int[6][7]; //根据稀疏数组定义原始数组
for (int i = 1; i < array2.length; i++) {
int x = array2[i][0]; //定义原始数组array3行,列,值分别为x,y,z
int y = array2[i][1];
int z = array2[i][2];
array3[x][y] = z;
}
for (int[] ints : array3) { //输出原始数组array3
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}