这篇文章的面向读者为Java初级程序员，也就是刚刚接触到Java这门语言，里面描述的内容主要是数组相关的内容，讲解了最基础的一些数组扩容思路，数组赋值机制，什么是引用地址，什么是基础数据赋值。
Java该章节数组内容
1. Java数组赋值机制
2. Java数组拷贝
3. Java数组反转
3.1 头尾交换法
3.2 逆序赋值法
4. Java数组扩容
5. Java数组缩减
6. Java数组排序
6.1 冒泡排序
Java数组赋值机制
基本数据类型赋值方式为 值拷贝/值传递 ， 但是数组在默认情况下是引用传递，默认赋值是地址。
数组拷贝（内容复制）
package array;
import java.util.Arrays;
/**
* 一维数组
*/
public class OneDimensionalArray {
/**
* 数组拷贝(非地址拷贝, 内容拷贝)
*/
public static void arrayCopy() {
int[] array1 = {1, 2, 3, 4, 5};
// 一旦出现new，则说明开辟新空间，则修改array2的数据不会影响array1
int[] array2 = new int[array1.length];
for (int i = 0; i < array1.length; i++) {
array2[i] = array1[i];
}
System.out.println(Arrays.toString(array2));
}
public static void main(String[] args) {
arrayCopy();
}
}
数组反转
头尾交换法
public static void arrayReverse() {
int[] array = {11, 22, 33, 44, 55, 66, 77, 88, 99};
// 这一步for循环是为了确定出遍历多少次，遍历的次数 = 数组的总数量 / 2 （交换次数）
for (int i = 0; i < array.length / 2; i++) {
// 首先存储倒数的array数据。 -i的用处是要向前遍历。 i是从前向后遍历。
int temp = array[array.length - 1 - i];
// 进行数据交换。先换后，然后换前。
array[array.length - 1 - i] = array[i];
array[i] = temp;
}
System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
arrayReverse();
}
逆序赋值法
/**
* 数组反转（逆序赋值法）
*/
public static void arrayReverse2() {
int[] array = {11, 22, 33, 44, 55, 66, 77, 88, 99};
// 定义一个新的数组，逆序遍历第一个数组，到第二个数组内
int[] array2 = new int[array.length];
// 创建两个变量，一个是i负责降序，一个是j负责升序，条件i遍历为0后结束。
for (int i = array.length - 1, j = 0; i >= 0 ; i--, j++) {
array2[j] = array[i];
}
// 此时array的地址指向array2 ，原先的地址没有了引用，则会被垃圾回收机制（GC）回收。
array = array2;
System.out.println(Arrays.toString(array2));
}
public static void main(String[] args) {
arrayReverse2();
}
数组扩容
定义一个初始数组，长度为4。当不够使用后，每次扩容为原有长度的一半（150%)，并且伴随用户输入来决定内容。
/**
* 数组扩容
*/
public static void arrayDilatation() {
// 定义一个初始数组，长度为4。当不够使用后，每次扩容为原有长度的一半（150%)
int[] array = new int[4];
// 定一个伪指针，用来记录当前索引位置。
int temp = 0;
while (true) {
// 这个scanner用来判断用户是否继续输入
Scanner str = new Scanner(System.in);
System.out.print("请输入yes/y来表明您想要继续添加: ");
String next = str.next();
// 继续执行
if ("yes".equals(next) || "y".equals(next)) {
// 为了防止有出现输入字符串的情况，使用try catch包裹
try {
// 创建输入流
Scanner scanner = new Scanner(System.in);
System.out.print("当前数组内已有元素为: " + temp + " 个，当前被添加的元素下标为: " + temp + " ，请输入新的记录的数字: ");
array[temp] = scanner.nextInt();
System.out.println("当前数组内已有数据为: " + Arrays.toString(array));
temp ++;
// 说明数组此时已经容量到达满量, 进行数组的扩容，每次扩容为当前数组的一半
if (temp == array.length) {
System.out.println("\n 数组内元素已满，进行自适应扩容，扩容数量为上次的150%, 具体数据如下。");
System.out.println("\t原有元素个数: " + temp + "\t扩容后元素个数: " + (array.length + array.length / 2) +
"\t 扩容数量为: " + (array.length / 2));
System.out.println("自适应扩容已完成。\n");
int[] dilatationArray = new int[array.length + array.length / 2];
// 进行数据拷贝 src：源数组 srcPos：复制的起始位置 dest：目标数组 destPos：目标数组开始存放的起始位置 length：需要复制的元素个数
System.arraycopy(array, 0, dilatationArray, 0, array.length);
// 让array指向新扩容后的数组。array原有的引用地址回收。
array = dilatationArray;
}
} catch (Exception e) {
System.out.println("输入的方式或字符形式不对，需要输入数字等一些规则。\n");
}
} else {
// 视为退出。退出前打印一下数组内元素
System.out.println("退出成功，目前已有元素集为: " + Arrays.toString(array));
break;
}
}
}
public static void main(String[] args) {
arrayDilatation();
}
数组缩减
有一个数组{1, 2, 3, 4, 5}，可以将该数组进行缩减，提示用户是否继续缩减，每次缩减最后的哪个元素，
当最后只剩下一个元素的时候，提示不能在缩减。结束程序。
/**
* 数组缩减
* 有一个数组{1, 2, 3, 4, 5}，可以将该数组进行缩减，提示用户是否继续缩减，每次缩减最后的哪个元素，
* 当最后只剩下一个元素的时候，提示不能在缩减。结束程序。
*/
public static void arrayReduce() {
int[] array = {1, 2, 3, 4, 5};
// 创建一个指针，保留最原始的数组长度
int temp = array.length;
// 哪怕是删到剩余一个，最多也就是遍历 temp - 1 次。
for (int i = 0; i < temp - 1; i++) {
Scanner next = new Scanner(System.in);
System.out.print("是否进行元素删减(y/*): ");
if ("y".equals(next.next())) {
// 删减元素后的数量
int[] newArray = new int[array.length - 1];
// 进行元素拷贝。
System.arraycopy(array, 0, newArray, 0, newArray.length);
// 改变引用
array = newArray;
System.out.println("删除完成，当前数组内存在元素为: " + Arrays.toString(array));
} else {
System.out.println("手动结束方法，剩余元素为: " + Arrays.toString(array) + ", 退出方法。");
return;
}
}
// 跳出循环后结束方法即可。
System.out.println("最少需要剩余一个元素, 目前达成条件，剩余元素为: " + Arrays.toString(array) + ", 退出方法。");
}
public static void main(String[] args) {
arrayReduce();
}
数组排序
排序分为 内部排序 和 外部排序 。
- 内部排序，指的是将所有需要排序的数据统统加载到 内部存储器中 进行排序（内存排序），包括（交换式排序法，选择式排序法和插入式排序法）
- 外部排序，数据量过大，无法全部加载到内存当中。需要借助外部存储进行排序，包括（合并排序法和直接合并排序法）
冒泡排序
有一个无序排序的数组 24, 69, 80, 57, 13 使用冒泡排序将其变成一个从小到大的有序数列
总结冒泡排序特点：
1.我们一共有5个元素
2.一共进行了 4轮排 可以看成是外层循环
3.每1轮排序可以确定一个数的位置，比如第1轮排序确定最大数,第2轮排序，确定第2大的数位置,依次类推
4.进行比较的时候，前面的数大于后面的数，就进行交换。
5.每轮比较的次数都在减少。
/**
* 冒泡排序
*/
public static void bubbleSort() {
int[] array = {24, 69, 80, 57, 13};
// 找一个存放数据的变量。
int temp;
for (int i = array.length - 1; i >= 0; i--) {
for (int j = 0; j < array.length -1; j++) {
if (array[j] > array[j + 1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
bubbleSort();
}
