Java基础：数组、排序和查找

一、数组 Array

1.1 简单介绍

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。
即：数组 就是一组数据。

1.2 案例演示

Array01.java

/**
 * title: 数组案例演示
 */
public class Array01 {
    public static void main(String[] args) {
        // 定义一个数组
        // 说明
        // 1.double[] 表示 是 double类型的数组数组名 hens
        // 2.{3, 5, 1, 3.4, 2, 50} 表示数组的值/元素，依次表示数组的第几个元素
        double[] hens = {3, 5, 1, 3.4, 2, 50, 7.8};
        // 遍历数组得到数组的所有元素的和，使用 for
        // 说明：
        // 1.我们可以通过 hens[下标] 来访问数组元素
        //   下标是从 0 开始编号的 比如第一个元素就是 hens[0]
        //   第二个元素 hens[1] 以此类推
        // 2.通过 for 循环就可以循环的访问 数组的元素/值
        // 3.使用一个变量 totalWeight 将各个元素累积
        double totalWeight = 0;
        // 提示：可以通过数组名.length 得到数组的长度/大小
        for (int i =0; i < hens.length; i++) {
            // System.out.println("第" + (i+1) + "个元素的值=" + hens[i]);
            totalWeight += hens[i];
        }
        double avgWeight = totalWeight / hens.length;
        System.out.println("总体重" + totalWeight + " 平均体重" + avgWeight);
    }
}

1.3 数组的使用

数组的定义
数据类型 数组名[] = new 数据类型[ 大小 ]
int a[] = new int[5]; // 创建了一个数组，名字 a，存放5个 int
说明：这是定义数组的一种方法
数组的引用（使用）
数组名[下标/索引] 比如：你要使用 a 数组的第3个数 a[2]

/**
 * title: 数组使用
 */
import java.util.Scanner;
public class Array02 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //演示 数据类型 数组名[] = new 数据类型[大小]
        //循环输入5个成绩，保存到double 数组，并输出
        // 步骤
        // 1.创建一个 double数组，大小 5
        double scores[] = new double[5];
        // 2.循环输入
        // scores.length 表示数组的长度
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第" + (i+1) + "个学生的成绩");
            scores[i] = scan.nextDouble();
        }
        // 3.遍历输出
        for (int j = 0; j < scores.length; j++) {
            System.out.println("第" + (j+1) + "个学生的成绩：" + scores[j]);
        }
    }
}

数组的使用 - 动态初始化

1. 先声明数组
   语法：数据类型 数组名[]; 也可以写成 数据类型[] 数组名;
   int a[]; 或者 int[] a;
2. 创建数组
   语法：数组名 = new 数据类型[大小];
   a = new int[10];

说明：上面是声明的同时创建数组，这里是先声明数组，后创建。不创建就没法对数组赋值
应用：有时需要等到某些条件满足时，我们才创建数组。

double scores[];  // 声明数组，这时 scores 是 null
scores = new double[5];  // 分配内存空间，可以存放数据

数组的使用 - 静态初始化
初始化数组
语法：数据类型 数组名[] = {元素值, 元素值, ……};
int a[] = {2, 3, 8, 45, 66}
使用案例见前面 Arry01.java

1.4 数组使用注意事项和细节

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理。
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3. 数组创建后，如果没有赋值，有默认值 int：0，short：0，byte：0，long：0，float：0.0，double：0.0，char：\u0000，boolean：false，String：null
4. 使用数组的步骤
   1. 声明数组并开辟空间
   2. 给数组各个元素赋值
   3. 使用数组
5. 数组的下标是从 0 开始的
6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如：
   int[] arr = new int[5]; 则有效下标为 0-4
7. 数组属于引用类型，数组型数据是对象（object）

1.5 数组应用案例

1. 创建一个 char 类型的26个元素的数组，分别放置 ‘A’ - ‘Z’。使用 for 循环访问所有元素并打印出来。
   提示：char 类型数据运算 ‘A’ + 1 -> ‘B’

2. 请求出一个数组 int[] 的最大值{4, -1, 9, 10, 23 }，并得到对应的下标。

public class ArrayExercise01 {
    public static void main(String[] args) {
        //创建一个 char 类型的26个元素的数组，
        //分别放置 'A' - 'Z'。使用 for 循环访问所有元素并打印出来
        // 定义数组 char类型(指定数组元素的数据类型) 数组名alphabet 长度26
        char alphabet[] = new char[26];
        // 循环输入'A' - 'Z'
        for (int i = 0; i < alphabet.length; i++) {
            // alphabet是Array[]数组类型，
            // alphabet[i]是数组alphabet的第i个元素，数组的元素是char类型
            alphabet[i] = (char)('A' + i);  // char参与运算会自动转成int int->char会报错
        }
        // 循环输出
        for (int i = 0; i < alphabet.length; i++) {
            System.out.print(alphabet[i] + " ");
        }
        System.out.println();
        // 请求出一个数组 int[] 的最大值{4, -1, 9, 10, 23 }，并得到对应的下标。
        int nums[] = {4, -1, 9, 10, 23 };
        int max = nums[0];  // 第一个元素默认是最大值
        int maxIndex = 0;   // 最大元素的下标
        // 遍历数组，依次与当前最大值比较
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > max) {  // 如果当前元素大于当前最大值
                max = nums[i];    // 更新 max 值
                maxIndex = i;     // 更新 最大元素的下标
            }
        }
        System.out.println("max = " + max + "\tmaxIndex = " + maxIndex);
    }
}

1.6 数组赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
   int n1 = 2; int n2 = n1;

2. 数组在默认情况下是引用传递，赋的值是地址。
   看一个案例，并分析数组赋值的内存图（重点）

   public class ArrayAssign {
    public static void main(String[] args) {
        // 基本数据类型赋值，赋值方式是值拷贝
        // n2 的变化不会 影响到 n1的值
        int n1 = 10;
        int n2 = n1;
        n2 = 80;
        System.out.println("n1 = " + n1);
        System.out.println("n2 = " + n2);
        // 数组默认情况下是引用传递,赋的值是地址,赋值方式为引用赋值
        // 赋的是一个地址,arr2的变化 会影响到 arr1
        int[] arr1 = {1, 2, 3};
        int[] arr2 = arr1;  // 把 arr1 赋给 arr2
        arr2[1] = 10;
        // 看看arr1的值
        System.out.println("====arr1的元素====");
        for (int i =0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "  ");
        }
    }
   }

   

1.7 数组拷贝

将 int[] arr1 = {1, 2, 3}; 拷贝到 arr2 数组，要求数据空间独立
ArrayCopy.java

public class ArrayCopy {
    public static void main(String[] args) {
        //将 int[] arr1 = {1, 2, 3};  拷贝到 arr2 数组，要求数据空间独立
        int[] arr1 = {1, 2, 3};
        // 创建一个新的数组arr2，开辟新的数据空间
        // 大小 = arr1.length
        int[] arr2 = new int[arr1.length];
        // 遍历 arr1数组，把每个元素拷贝到对应的arr2数组中
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        // 遍历 arr2数组，检查是否拷贝过来
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + "  ");
        }
        //修改 arr2数组的元素，验证是否会影响 arr1数组
        arr2[1] = 10;
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "  ");
        }
    }
}

1.8 数组反转

把数组的元素内容反转。
arr {11, 22, 33, 44, 55, 66} -> {66, 55, 44, 33, 22, 11}

方法一：通过找规律反转 ArrayReverse.java

public class ArrayReverse {
    public static void main(String[] args) {
        // 定义数组
        int arr[] = {11, 22, 33, 44, 55, 66};
        // 思路分析
        // 1. 把 arr[0] 和 arr[5] 进行交换 {66, 22, 33, 44, 55, 11}
        // 2. 把 arr[1] 和 arr[4] 进行交换 {66, 55, 33, 44, 22, 11}
        // 3. 以此类推，直至最中间的两个进行交换(如果剩1个，和自己交换)
        // 4. 一共要交换 (arr.length / 2) 次
        // 5. 每次交换时，对应的下标是 arr[i] 和 arr[arr.length - 1 - i]
        // 代码实现
        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; // 把保存的后面元素的值赋值给前面元素，完成交换
        }
        System.out.println("====翻转后的数组====");
        for (int i = 1; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

方法二：使用逆序赋值方式 ArrayReverse02.java

public class ArrayReverse02 {
    public static void main(String[] args) {
        // 定义数组
        int arr[] = {11, 22, 33, 44, 55, 66};
        // 使用逆序赋值
        // 思路分析
        // 1.先创建一个新的数组 arr2,与原数组arr长度相同
        // 2.逆序遍历原数组arr ,将每个元素拷贝到arr2的元素中(顺序拷贝)
        // 3.建议增加一个循环变量 j -> 0 -> 5
        int arr2[] = new int[arr.length];
        for (int i = arr.length - 1,j = 0; i >= 0; i--,j++) {
            arr2[j] = arr[i];
        }
        // 4. 当 for 循环结束,arr2就是arr的逆序数组
        // 5. 让 arr 指向 arr2 的数据空间,此时 arr原来的数据空间就没有变量引用
        //       会被当作垃圾销毁
        arr = arr2;
        System.out.println("====翻转后的数组====");
        for (int i = 1; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

1.9 数组添加（扩容）

要求：实现动态的给数组添加元素的效果，实现对数组扩容

1. 原始数组使用静态分配：int[] arr = {1, 2, 3}
2. 增加的元素，直接放在数组的最后 arr = {1, 2, 3, 4}
   arrNew = {1, 2, 3, 4}
3. 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？ y/n

import java.util.Scanner;
public class ArrayAdd {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int[] arr = {1, 2, 3};
        char said = 'y';
        while (said == 'y') {
            int arrNew[] = new int[arr.length + 1];
            System.out.println("请输入新增元素：");
            int add = scan.nextInt();
            for (int i = 0; i < arr.length; i++) {
                arrNew[i] = arr[i];
            }
            arrNew[arr.length] = add;
            arr = arrNew;
            System.out.println("==== 扩增后的数组arr ====");
            for (int i = 0; i < arr.length; i++) {
                    System.out.print(arr[i] + "  ");
            }
            System.out.println("添加成功，是否继续？ y/n");
            said = scan.next().charAt(0);
        }
    }
}

⏱小练习
有一个数组 {1, 2, 3, 4, 5} ，可以将该数组进行缩减（从后向前依次），提示用户是否继续缩减，每次缩减的元素值是什么。当只剩下最后一个元素，提示，不能再缩减。

二、排序

2.1 简单介绍

排序是将一群数据，依照指定的顺序进行排列的过程
排序的分类：

1. 内部排序：
   指将需要处理的所有数据都加载到内部存储器中进行排序。
   包括：交换式排序法、选择式排序法、插入排序法
2. 外部排序法：
   数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
   包括：合并排序法、直接合并排序法

2.2 冒泡排序法

基本思想：
通过对 待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，做发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底的气泡一样逐渐向上冒。

2.3 案例演示

BubbleSort.java

public class BubbleSort {
    public static void main(String[] args) {
        int sums[] = {24, 69, 80, 57, 13};
        for (int j = 1; j < sums.length; j++) {    // 定义要进行几轮比较
            for (int i = 0; i < sums.length - j; i++) {  // 每轮冒泡具体实现
                if (sums[i] > sums[i + 1]) {
                    int temp = sums[i];
                    sums[i] = sums[i + 1];
                    sums[i + 1] = temp;
                }
            }
            for (int k = 0; k < sums.length; k++) {
                System.out.print(sums[k] + "  ");  // 可以看到每轮排序后的结果
            }
            System.out.println();
        }
    }
}

笔者已经学过数据结构，这里不做多注释，看不懂的可以参考这两个视频，讲解比较详细。
冒泡排序思路讲解：https://www.bilibili.com/video/BV1fh411y7R8?p=173
冒泡排序代码实现：https://www.bilibili.com/video/BV1fh411y7R8?p=174

三、查找

3.1 简单介绍

在Java中，我们常用的查找有两种：

1. 顺序查找
   从前到后依次比较，直到查找成功为止，或者全都对不上，查找失败。
2. 二分查找（放在算法章节讲）
   要查找的对象是有序的【前提】，每次与最中间元素的值比较，再确定向前或者向后继续进行递归的二分查找，直到查找成功为止，或者全都对不上，查找失败。

3.2 案例演示

顺序查找：SeqSearch.java

import java.util.Scanner;
public class SeqSearch {
    public static void main(String[] args) {
        /*
        有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：
        从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】
        要求：如果找到了，就提示找到，并给出下标
        思路分析
        1. 定义一个字符串数组
        2. 接收用户输入，遍历数组，逐一比较，如果有，则提示信息，并退出
        */
        Scanner scan = new Scanner(System.in);
        String names[] = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
        System.out.println("请输入一个四大法王名字");
        String name = scan.next();
        int index = -1;
        for (int i = 0; i < names.length; i++) {
            if (names[i].equals(name)) {
                System.out.println("找到了，对应下标为" + i);
                //把 i 保存到 index
                index = i;
                break;
            }
        }
        if (index == -1) {
            System.out.println("没有找到" + name);
        }
    }
}

四、多维数组 - 二维数组

4.1 简单介绍

1. 从定义形式上看 int[][]。
2. 可以这样理解，原来的一维数组的每个元素又是一个一维数组，就构成二维数组。
   每个一维数组长度可以不一样。
3. 访问二维数组下标 i 的元素的第下标 j 的值 ：int[ i ][ j ]

4.2 案例演示

TwoDimensionalArray.java

/**
 * title: 二维数组案例演示 TwoDimensionalArray.java
 */
public class TwoDimensionalArray {
    public static void main(String[] args) {
        /*
        请用二维数组输出如下图形
        0 0 0 0 0 0
        0 0 1 0 0 0
        0 2 0 3 0 0
        0 0 0 0 0 0
         */
        int[][] arr = { {0, 0, 0, 0, 0, 0}, 
                        {0, 0, 1, 0, 0, 0}, 
                        {0, 2, 0, 3, 0, 0}, 
                        {0, 0, 0, 0, 0, 0} };
        // 输出二维图形
        for (int i = 0; i < arr.length; i++) {  // 遍历二维数组的每个元素
            // 遍历二维数组的每个元素
            // 1. arr[i] 表示二维数组的第i个元素，因为元素值也是数组(一维)
            //       所以arr[i].length 就是该元素(一维数组)的长度
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");  // 输出一维数组
            }
            System.out.println();  // 换行
        }
    }
}

4.3 二维数组的使用

使用方式1：动态初始化

1. 语法：数据类型[][] 数组名=new 类型[大小][大小]
2. 比如：int a[][] = new int[2][3] 定义一个二维数组a，含有两个长度为3的一维数组
3. 二维数组在内存的存在形式

使用方式2：动态初始化

1. 先声明：数据类型[][];
2. 再定义(开辟空间) 数组名 = new 数据类型[大小][大小]
3. 赋值(有默认值，同一维数组)

   int arr[][];  // 声明二维数组
   arr = new int[2][3];  // 定义

使用方式3：动态初始化 - 列数不确定
看一个需求：动态创建下面的二维数组，并输出

案例演示 TwoDimensionalArray03.java

/**
 * title: 二维数组动态初始化 - 列数不确定 案例演示
 */
public class TwoDimensionalArray03 {
    public static void main(String[] args) {
        // 一共有三个一维数组，每个长度不一样
        int[][] arr = new int[3][];  // 创建二维数组，只确定有多少个元素
        for (int i = 0; i < arr.length; i++) {  // 遍历arr每一个一维数组
            // 给每个一维数组开空间 new
            // 如果没有给一维数组，那么 arr[i] 就是null
            arr[i] = new int[i + 1];
            // 遍历一维数组，并给一维数组的每个元素赋值
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = i + 1;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

使用方式4：静态初始化

1. 定义：数据类型 数组名[][] = { { 值1, 值2…… }, { 值1, 值2…… }.{ 值1, 值2…… }…… };
2. 案例演示 见前面 TwoDimensionalArray.java

4.4 二维数组的遍历

TwoDimensionalArray04.java

/**
 * title: 二维数组的遍历
 */
public class TwoDimensionalArray04 {
    public static void main(String[] args) {
        // 需求：遍历二维数组，并求和
        int arr[][] = {{4, 6}, {1, 4, 5, 7}, {-2}};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        System.out.println("二维数组的和是" + sum);
    }
}

4.5 二维数组的应用案例

1. 使用二维数组打印一个 10 行 杨辉三角
   1
   1 1
   1 2 1
   1 3 3 1
   1 4 6 4 1
   1 5 10 10 5 1
   ……
   YangHui.java

   /**
   * title: 杨辉三角二维数组
   */
   public class YangHui {
    public static void main(String[] args) {
        /*
        1
        1 1
        1 2 1
        1 3 3 1
        1 4 6 4 1
        1 5 10 10 5 1
        一共 10 行
        规律：
        1. 第一行有 1 个元素，第 n 行有 n 个元素
        2. 每一行的第一个元素和最后一个元素都是1
        3. 从第 3 行开始，对于非第一个元素和最后一个元素的值 yang[i][j]
           yang[i][j] =  yang[i - 1][j - 1] + yang[i - 1][j];  // 必须找到这个规律
         */
        int[][] yang = new int[10][];
        for (int i = 0; i < yang.length; i++) {  // 遍历二维数组每个元素
            // 给每个一维数组开辟空间
            yang[i] = new int[i + 1];
            for (int j = 0; j < yang[i].length; j++) {
                // 每一行的第一个元素和最后一个元素都是 1
                if (j == 0 || j == yang[i].length - 1) {
                    yang[i][j] = 1;
                } else {  // 中间元素
                    yang[i][j] =  yang[i - 1][j - 1] + yang[i - 1][j];
                }
            }
        }
        // 输出杨辉三角
        for (int i = 0; i < yang.length; i++) {
            for (int j = 0; j < yang[i].length; j++) {
                System.out.print(yang[i][j] + " ");
            }
            System.out.println();
        }
    }
   }

4.6 二维数组使用细节和注意事项

1. 一维数组的声明方式有：
   int[] x 或者 int x[]
2. 二维数组的声明方式有：
   int[][] y 或者 int[] y[] 或者 int y[][]
3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不同。
   比如：map[][] 是一个二维数组
   int map[][] = {{1, 2}, {3, 4, 5}};
   由 map[0] 是一个含有两个元素的一维数组，map[1]是一个含有三个元素的一维数组构成，我们也成为列数不等的二维数组。

⏱ 小练习
声明：int[] x,y[]；以下选项允许通过编译的是（b e ）

1. x[0] = y;
2. y[0] = x;
3. y[0][0] = x;
4. x[0][0] = y;
5. y[0][0] = x[0];
6. x = y;

五、本章作业

1. 下面数组定义正确的有bd__

   1. String strs[] = { ‘a’, ‘b’, ‘c’ };
   2. String[] strs = { “a”, “b”, “c” };
   3. String[] strs = new String{ “a”, “b”, “c” };
   4. String strs[] = new String[]{ “a”, “b”, “c” };
   5. String[] strs = new String[3]{ “a”, “b”, “c” };

2. 写出结果
   String foo = “blue”;
   boolean[] bar = new boolean[2];
   if ( bar[0] ) {
   foo = “green”;
   }
   System.out.println( foo );

3. 以下Java代码的输出结果为
   int num=1;

while ( num < 10 ) {
System.out.println( num );
if（num>5）{
break；
}
num+=2；
}

1. 已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序，
   比如：[10，12，45，90]，添加23后，数组为[10，12，23，45，90]

   public class Homework04 {
    public static void main(String[] args) {
        int[] arr = {10, 12, 45, 90};
        int insert = 23;   // 插入的新值(可以改成用户键盘输入方式)
        int i = 0;         // 用于确定新值的插入位置
        while (arr[i] < insert) {  // 循环遍历数组，找到插入位置
            i++;
            if (i == arr.length) {
                break;  // 如果新值比数组所有值都大，立即退出while循环，否则会发生越界报错
            }
        }
        int[] arrNew = new int[arr.length + 1];  // 扩充数组
        arrNew[i] = insert;   // 新值先插入到之前确定的位置
        for (int j = 0; j < arrNew.length - 1; j++) {  // 把arr的值依次插入到扩充数组
            if (j < i) {
                arrNew[j] = arr[j]; 
            } else {
                arrNew[j + 1] = arr[j];
            }
        }
        arr = arrNew;  // arr 指向扩充数组
        for (int k = 0; k < arr.length; k++) {
            System.out.println(arr[k] + " ");
        }
    }
   }

2. 随机生成10个整数（1-100的范围）保存到数组，并倒序打印以及求平均值、求最大值和最小值及其下标、并查找里面是否有8，用冒泡排序法从小到大排序 ```java

public class Homework05 {

public static void main(String[] args) {
    // 定义一个保存10个随机数的数组
    int[] arr = new int[10];
    int sum = 0;
    // 生成10个随机数并依次保存到数组
    for (int i = 0; i < arr.length; i++) {
        arr[i] = (int)(Math.random() * 100 + 1);
        System.out.print(arr[i] + " ");
    }
    System.out.println(); // 换行
    // 倒序输出
    for (int i = arr.length - 1; i >=0; i--) {
        System.out.print(arr[i] + " ");
        sum += arr[i];   // 累积求和
    }
    // 求平均值
    System.out.println("平均值为" + (double)sum / arr.length);
    // 求最大值及下标
    int max = arr[0];
    int index1 = 0;
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
            index1 = i;
        }
    }
    System.out.println("最大值为" + max + "下标为" + index1);
    // 求最小值及下标
    int min = arr[0];
    int index2 = 0;
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
            index2 = i;
        }
    }
    System.out.println("最小值为" + min + "下标为" + index2);
    // 查找里面是否有8
    int index3 = -1;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == 8) {
            System.out.println("数组里面有8，下标为" + i);
            index3++;
        }
    }
    if (index3 == -1) {
        System.out.println("数组里面没有8");
    }
    // 冒泡排序
    int change = 0;
    int isChange = -1;
    for (int i = 0; i < arr.length - 1; i++) {
        isChange = change;  // 上次冒泡排序后 记录调换动作 的值
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
                change++;  // 记录调换动作
            }
        }
        if (isChange == change) { // 上次和本次对比
            break;  // 如果本次没有进行排序调换动作，直接提前退出
        }
        for (int k = 0; k < arr.length; k++) {
            System.out.print(arr[k] + " ");
        }
        System.out.println();
    }
}

} ```

1. 试写出以下代码的打印结果
   char[] arr1 = {‘a’，’z’，’b’，’c’）；

char[] arr2 = arr1；
arr1[2] = ‘韩’；
for（int i = 0；i < arr2.length；i++）{
System.out.println（arr1[i] + “，” + arr2[i] );
}

学习参考（致谢）：

1. B站 @程序员鱼皮 Java学习一条龙
2. B站 @韩顺平 零基础30天学会Java