Java数组 Java数组

什么是数组？
数组是相同类型数据的有序集合
数组中每个数据称为元素，每个元素可以通过一个下标来访问。数组下标从0开始

数组声明创建

必须声明数组变量，才能在程序中使用数组

dataType[] arrayRefVar; //首选
?
dataType arrayRefVar[]; //效果相同，但不是首选
Java语言使用new操作符来创建数组

dataType[] arrayRefVar = new dataType[arraySize];
数组元素是通过索引访问的，数组索引从0开始
获取数组长度：array.length
三种初始化
- 静态初始化：创建+赋值
  
  int[] nums = {1,2,3,4,5,6,7,8};
- 动态初始化：包含默认初始化
  
  int[] nums = new int[10];
  nums[0] = 10;
- 数组的默认初始化
  数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
数组边界
- 下标的合法区间[0，length-1]
- ArrayIndexOutOfBoundsException：数组下标越界异常

数组使用
普通的for循环
for-each循环
数组作参数
数组作返回值

多维数组
多维数组可以看成是数组的数组。如二维数组，就是一个特殊的一维数组，其每一个元素都是一个一维数组
二维数组

int[][] a = new int[2][5]; //一个两行五列的数组

Arrays类
数组的工具类：java.util.Arrays
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用“使用对象来调用”（不用不是不能）
具有以下常用功能：

给数组赋值：fill方法
对数组排序：sort方法（升序）
比较数组：equals方法比较数组中元素值是否相等
查找数组元素：binarySearch方法对排序好的数组进行二分查找法操作

冒泡排序
冒泡的代码相当简单，两层循环，外层冒泡轮数，里层依次比较，时间复杂度为O(n^2)

package array;
?
import javax.sound.midi.Soundbank;
import java.util.Arrays;
?
public class Demo02 {
public static void main(String[] args) {
int[] a = {1,4,5,6,72,2,2,2,25,6,7};
sort(a);
?
System.out.println(Arrays.toString(a));
?
}
?
public static int[] sort(int[] array) {
//外层循环
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较相邻的两个数
for (int j = 0; j < array.length-i-1; j++) {
if(array[j+1] > array[j]) {
int temp = array[j+1];
array[j+1] = array[j];
array[j] = temp;
}
}
}
?
return array;
}
}

稀疏数组
当一个数组中大部分元素为0，或其他值，可使用稀疏数组来保存
处理方式是：

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

如下：
$$
\left( \begin{matrix} 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 \end{matrix} \right)
$$

	行（row）	列（col）	值（val）
[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

package array;
?
public class Demo03 {
public static void main(String[] args) {
//创建二维数组 11*110：没有棋子1：黑子2：白子
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
?
//输出原始的数组
System.out.println("输出原始的数组");
for (int[] ints:array1) {
for (int num:ints) {
System.out.print(num+"\t");
}
System.out.println();
}

//转换为稀疏数组保存
//获取有效值的个数
int sum = 0;
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);

//创建稀疏数组
int[][] array2 = new int[sum+1][3];

array2[0][0] = 11;
array2[0][1] = 11;
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];
}
}
}
?
//输出稀疏数组
System.out.println("输出稀疏数组");
for (int i = 0; i < array2.length; i++) {
for (int j = 0; j < array2[i].length; j++) {
System.out.print(array2[i][j]+"\t");
}
System.out.println();
}
?
//还原稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
?
//打印还原数组
System.out.println("输出还原数组");
for (int[] ints:array3) {
for (int num:ints) {
System.out.print(num+"\t");
}
System.out.println();
}
}
}