一、数组的概念
数组是相同数据类型元素的集合。
数组本身是引用数据类型，但它可以存储基本数据类型和引用数据类型。
二、数组的声明
语法一：数据类型[] 数组名;
语法二：数据类型 数组名[];
三、数组的创建
两个要素：数据类型、长度。
语法一：数据类型[] 数组名 = new 数据类型[长度];(动态初始化，先定义数组，然后初始化数据)
语法二：数据类型[] 数组名 = new 数据类型[]{初始化数据};(静态初始化，定义数组的同时，初始化数据)
语法三：数据类型[] 数组名 = {初始化数据};(静态初始化)
例：
//定义数组语法一
@Test
public void test_01(){
int[] arr = new int[3];
System.out.println(arr.length);
}
//定义数组语法二
@Test
public void test_02(){
int[] arr = new int[]{12,11,10};
System.out.println(arr.length);
}
//定义数组语法三
@Test
public void test_03(){
int[] arr = {12,11,10};
System.out.println(arr.length);
}四、数组的特点
数组一旦定义，长度不变。
存储的数据类型相同。
数组的长度length是属性。
数组在内存当中处于连续的内存空间。
五、访问数组元素
访问数组元素需要使用索引，数组的索引从0开始，最大值为数组的长度减一。
语法：数组名[索引]
例：
//访问数组元素
@Test
public void test_04(){
int[] arr = {11,12,13};
//输出数组的第一个元素
System.out.println(arr[0]);
}六、数组的遍历
数组遍历就是通过索引获取数组中的每个元素。
例：
//for循环遍历数组
@Test
public void test_05(){
int[] arr = {1,2,3,4,5,6};
for(int i= 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
//while循环遍历数组
@Test
public void test_06(){
int[] arr = {1,2,3,4,5,6};
int i = 0;
while(i < arr.length){
System.out.println(arr[i]);
i++;
}
}七、数组中常见的异常
ArrayIndexOutOfBoundsException：数组索引越界异常。
NullPointerException：空指针异常。
八、获取数组中的最大值
例：
//获取数组中的最大值
@Test
public void test_07(){
int[] arr = {89,66,8,5,99,3,5,66,78,100};
int max = arr[0];
for (int i = 1; i < arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
System.out.println("数组中的最大值为："+max);
}九、数组的逆序
原理：首尾元素两两交换。
逆序不等于反向遍历。
例：
//数组的逆序
@Test
public void test_13(){
//定义数组
int[] arr = {1,2,3,4,5};
int temp;
for(int i = 0;i <=(arr.length/2); i++){
temp = arr[i];
//数组的长度比索引大1,所以要减去1
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
//遍历输出逆序后的数组
for (int i = 0; i < arr.length;i++){
System.out.println(arr[i]);
}
}十、二维数组的声明
语法：数据类型[][] 数组名;
十一、二维数组的创建
语法一：数据类型[][] 数组名 = new int[二维数组的长度][一维数组的长度];
语法二：数据类型[][] 数组名 = new int[二维数组的长度][];(此种方式定义的一维数组需要另外分配长度，其长度可以不相同)
语法三：数据类型[][] 数组名 = new int[][]{{初始化数据},{初始化数据}};(每一对花括号是一个一维数组，使用逗号分割。此种方式定义的一维数组的长度可以不相同)
例：
//二位数组的创建方式一
@Test
public void test_08(){
int[][] arr = new int[3][5];
//输出二位数组的长度
System.out.println(arr.length);
//输出第一个一维数组的长度
System.out.println(arr[0].length);
}
//二位数组的创建方式二
@Test
public void test_09(){
int[][] arr = new int[3][];
arr[0] = new int[5]; //给第一个一维数组分配大小
arr[1] = new int[6]; //给第二个一维数组分配大小
//输出二位数组的长度
System.out.println(arr.length);
//输出第一个一维数组的长度
System.out.println(arr[0].length);
//输出第二个一维数组的长度
System.out.println(arr[1].length);
}
//二位数组的创建方式三
@Test
public void test_10(){
int[][] arr = new int[][]{{10,11,12},{10,11,12,13}};
//输出二位数组的长度
System.out.println(arr.length);
//输出第一个一维数组的长度
System.out.println(arr[0].length);
//输出第二个一维数组的长度
System.out.println(arr[1].length);
}十二、通过索引访问二维数组中的数据
语法：数组名[二维数组的索引][一维数组的索引]
例：
//访问数组中的元素
@Test
public void test_11(){
int[][] arr = new int[][]{{10,20},{50,66}};
//输出第二个一维数组中的第一个元素
System.out.println(arr[1][0]);
}十三、二维数组的遍历
思路：for循环的嵌套，外层循环遍历二维数组，内层循环遍历一维数组。
例：
//for循环遍历二维数组
@Test
public void test_12(){
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//外层循环遍历二维数组
for(int i = 0; i < arr.length; i++){
//内层循环遍历一维数组
for (int j = 0; j < arr[i].length; j++){
//输出每次遍历所获取的元素
System.out.println(arr[i][j]);
}
}
}十四、选择排序
原理：数组中的每个元素和其他的元素比较大小，根据排序要求交换位置。
思路：使用for的嵌套循环。外层循环控制比较次数，内循环控制每次比较的元素。
例：
//选择排序
@Test
public void test_14(){
//定义一维数组
int[] arr = {56,98,36,33,88,77,88,4,6,99};
//最后剩余的一个元素不用比较，所以要减1
for (int i = 0; i < arr.length - 1; i++){
for (int j = 1+i; j < arr.length; j++){
if(arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
//遍历输出数组元素
for (int i = 0; i < arr.length;i++){
System.out.print(arr[i]+" ");
}
}十五、冒泡排序
原理：每轮冒泡，数组中相邻元素两两比较，根据排序要求交换位置。外层循环控制冒泡的次数，内层循环控制每次比较的元素。
例：
//冒泡排序
@Test
public void test_15(){
//定义一维数组
int[] arr = {88,66,23,44,5,6,77,99,52,-9};
for (int i = 0; i < arr.length-1; i++){
for (int j = 0; j < arr.length-i-1; j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//遍历输出数组元素
for (int i = 0; i < arr.length;i++){
System.out.print(arr[i]+" ");
}
}