public class ArrayReverse {
	public static void main(String[] args) {
		
		int[] arr = {11, 22, 33, 44, 55, 66};

		for( int i = 0; i < arr.length / 2; i++) { 
			int temp = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = arr[i];
			arr[i] = temp;
		}
		for( int i = 0; i < arr.length ; i++) {
			System.out.print(arr[i] + " ");
		}
		
	}
}

输出结果为：

分析：

1）把 arr[0] 和 arr[5] 进行交换 {66, 22, 33, 44, 55, 11}

2）把 arr[1] 和 arr[4] 进行交换 {66, 55, 33, 44, 22, 11}

3）把 arr[2] 和 arr[3] 进行交换 {66, 55, 44, 33, 22, 11}

4）一共要交换三次，所以总共循环次数应为 arr.length / 2 次

5）每次交换时，对应的下标是 arr[i] 和 arr[arr.length - 1 - i]

（2）方法二

public class ArrayReverse02 {
	public static void main(String[] args) {

		int[] arr = {11, 22, 33, 44, 55, 66};

		int[] arr2 = new int[arr.length];
		for( int i = arr.length - 1 , j = 0; i >= 0 ; i-- , j++) {
			arr2[j] = arr[i];
		}
		arr = arr2;
		//当 arr 指向 arr2 数据空间，此时 arr 原来的数据空间就没有

		for( int i = 0 ; i < arr.length ; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}

输出结果为：

分析：

1）先创建一个新的数组 arr2, 大小为 arr.length

2）逆序遍历 arr，将每个元素拷贝到 arr2的元素中

3） arr 指向 arr2 数据空间，此时 arr 原来的数据空间就没有了，会被当做垃圾销毁

二、数组扩容

案例：

实现动态的给数组添加元素效果，实现对数组扩容。要求： 1）原始数组使用静态分配， int [ ] = arr{1, 2, 3} 2）增加一个元素，使其添加到数组最后，例如增加元素4后 int [ ] = arr{1, 2, 3, 4} 3）用户可以通过如下方法来决定是否继续添加——添加成功，是否继续添加？y/n

import java.util.Scanner;
public class ArrayAdd {
	public static void main(String[] args) {
		
		Scanner myScanner = new Scanner(System.in);
		
		  int[] arr = {1, 2, 3};
		do {

			int[] arrNew = new int[arr.length + 1];
			// 遍历arr数组，依次将arr的元素拷贝到 arrNew数组
			for(int i = 0; i < arr.length; i++) {
				 arrNew[i] = arr[i];
			}
			System.out.println("请输入你要添加的元素：");
			int addNum = myScanner.nextInt();

			arrNew[arrNew.length - 1] = addNum; //把addNum赋给arrNew的最后一个元素

			arr = arrNew;//让 arr 指向 arrNew
			for(int i = 0; i < arr.length; i++) {
				System.out.print(arr[i] + "\t");
			}
			//问用户是否继续
			System.out.println("是否继续输入 y/n:");
			char c = myScanner.next().charAt(0);//接收 y / n
			if(c == 'n') { //如果输入n就结束循环
				break;

			}
		} while (true);
		System.out.println("已退出添加");
	}
}

输出结果为：

分析：

1）定义一个初始数组，int[ ] arr = {1, 2, 3};

2）定义一个新的数组，int[ ] arrNew = new int[arr.length + 1]; 因为要存放新的数据，所以数组大小要加1

3）遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组

4）将输入的数据赋给 arrNew[arrNew.length - 1] ，理解为将输入的数赋给 arrNew 数组的最后一个元素

5）因为用户什么时候退出不确定，所以使用使用 do - while 和 break 来控制

三、数组排序（冒泡法）

排序是指将多个数据，按指定的顺序进行排列的过程。

冒泡排序法：通过比较两个相邻的数的大小（如果前面的数大于后面的数就进行交换 / 后面的数大于前面的数就进行交换），来进行一个数组的排序，使整个数组中的数据按从小到大/从大到小的顺序进行排序。

案例：

将五个无序的数：24,69,80,57,13 使用冒泡排序法将其排成一个从小到大的有序数列。

运行目标：

数组[24,69,80,57,13] 第一轮循环:目标是把最大的数放到数组最后位置第1次比较 [24,69,80,57,13] 第2次比较 [24,69,80,57,13] 第3次比较 [24,69,57,80,13] 第4次比较 [24,69,57,13,80]
第二轮循环:目标是把第二大的数放到数组倒数第二位置第1次比较 [24,69,57,13,80] 第2次比较 [24,57,69,13,80] 第3次比较 [24,57,13,69,80]
第三轮循环:目标是把第三大的数放到数组倒数第三位置第1次比较 [24,57,13,69,80] 第2次比较 [24,13,57,69,80]
第四轮循环:目标是把第三大的数放到数组倒数第四位置第1次比较 [13,24,57,69,80]

代码：

public class BubbleSort {
	public static void main(String[] args) {
		
		int[] arr = {24 , 69 , 80 , 57 , 13};
		int temp; //用于辅助变量交换

		// 先死后活 => 4就是 arr.length - 1
		for(int i = 0; i < arr.length - 1; i++) {// 外层循环四次

			for(int j = 0; j < arr.length -1 -i; j++) { 
            // 四次比较 -> 三次 -> 二次 -> 一次
			
			// 如果后面的数大于前面的数就进行交换
			if(arr[j] > arr[j + 1]) {
				temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
				}
			}
			System.out.println("\n ===第" + (i + 1) + "轮");
			for(int j = 0; j < arr.length ; j++) {
				System.out.print(arr[j] + "\t");
			}
		}
	}
}

运行结果：