feat: 20260716课堂笔记（多维数组、forEach、Arrays工具类与数组进阶练习）

- 新增多维数组、增强for循环、Arrays工具类授课笔记及代码
- 新增7月15日课后作业（数组求和、找最大值、倒序输出、奇偶统计）
- 新增课堂练习（首尾交换、循环右移、数组去重）
- 补充课前练习（20260715-数组进阶练习题）
- 更新README.md添加20260716笔记和代码项目链接

README.md

@@ -25,6 +25,7 @@
 | 2026-07-13 | [JavaSE 基础入门](./课堂笔记/01-JavaSE基础-笔记/20260713-笔记.md) |
 | 2026-07-14 | [Java 运算符与流程控制](./课堂笔记/01-JavaSE基础-笔记/20260714-笔记.md) |
 | 2026-07-15 | [switch分支、循环结构、嵌套循环与数组](./课堂笔记/01-JavaSE基础-笔记/20260715-笔记.md) |
+| 2026-07-16 | [多维数组、forEach、Arrays工具类与数组进阶练习](./课堂笔记/01-JavaSE基础-笔记/20260716-笔记.md) |
 
 ## 二、授课代码
 
@@ -36,4 +37,5 @@
 | 2026-07-13 | JavaSE 基础入门 | `javaSE-260713-FirstJava` | [默认包](./授课代码/javaSE-260713-FirstJava/src/) |
 | 2026-07-14 | Java 运算符与流程控制 | `c260714` | [默认包](./授课代码/c260714/src/) |
 | 2026-07-15 | switch分支、循环结构与数组 | `c260715` | [默认包](./授课代码/c260715/src/) |
+| 2026-07-16 | 多维数组、forEach、Arrays工具类与数组进阶练习 | `c260716` | [默认包](./授课代码/c260716/src/) |
 

授课代码/c260716/.gitignore

@@ -0,0 +1,30 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+.kotlin
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

授课代码/c260716/src/Demo01.java

@@ -0,0 +1,56 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 多维数组
+ * @create 2026/7/16
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        /*
+            一维数组中所有的元素都是数据类型的变量或常量
+            二维数组中所有的元素都是一维数组
+            三维数组中所有的元素都是二维数组
+            ......
+
+            Java多维数组的本质：其实就是数组的数组，二维数组的元素其实就是一维数组的引用地址值
+
+            二维数组的定义的格式：
+            数组类型[][] 数组名=new 数组类型[二维数组长度][一维数组长度];
+         */
+        //数组类型[][] 数组名=new 数组类型[二维数组长度][一维数组长度];
+        int[][] arr = new int[3][2];  //[行数][列数]
+
+        //遍历二维数组需要两层循环嵌套
+        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();
+        }
+        // 静态初始化二维数组----三行三列
+        int[][] arr1 = {
+                {1, 2, 3},
+                {4, 5, 6},
+                {7, 8, 9}
+        };
+        for (int i = 0; i < arr1.length; i++) {
+            for (int j = 0; j < arr1[i].length; j++) {
+                System.out.print(arr1[i][j] + " ");
+            }
+            System.out.println();
+        }
+
+        // 二维数组中的一维数组，不是必须要相同长度的，长度是不一样的。
+        int[] arr01={1, 3};
+        int[] arr02={4, 5, 6};
+        int[] arr03={7, 8, 9,15};
+        int[][] arr2 = {arr01,arr02,arr03}; //二维数组存放的其实就是一维数组的引用地址
+        for (int i = 0; i < arr2.length; i++) {
+            for (int j = 0; j < arr2[i].length; j++) {
+                System.out.print(arr2[i][j] + " ");
+            }
+            System.out.println();
+        }
+    }
+}

授课代码/c260716/src/Demo02.java

@@ -0,0 +1,40 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description foreach迭代-增强for循环
+ * @create 2026/7/16
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        //我们之前使用的for循环，是for(int i=0;i<10;i++)
+        //可以使用增强for循环--foreach，作用和for循环一样
+        //主要是用来进行数组遍历
+        /*
+            格式：
+                for(数据类型 变量 : 数组名){
+                    代码块
+                }
+         */
+        int[] arr = {1, 2, 3, 4, 5, 6, 8};
+        for (int a : arr) {
+            System.out.print(a + " ");
+        }
+        System.out.println();
+        /*
+            foreach 遍历的数组，无法获取索引值，所以只适合遍历全部元素。想要获取某个索引位置的元素，需要for循环
+         */
+
+        int[] arr01 = {1, 3};
+        int[] arr02 = {4, 5, 6};
+        int[] arr03 = {7, 8, 9, 15};
+        int[][] arr2 = {arr01, arr02, arr03};
+        for (int[] a : arr2) { //外层foreach
+            for (int a1 : a) { //内层foreach
+                System.out.print(a1 + " ");
+            }
+            System.out.println();
+        }
+
+    }
+}

授课代码/c260716/src/Demo03.java

@@ -0,0 +1,35 @@
+import java.util.Arrays;
+
+// import 是导包的关键字， 后面跟着的是【类全路径名】--包名.类名
+// 使用某个类的时候，一定要先导包
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description 数组工具类 ： java.util.Arrays;   最后的是类名，前面的是包名
+ * @create 2026/7/16
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        /*
+            数组工具类 ： java.util.Arrays;
+            java中的命名特点，如果一个类的类名 是名词+s，那么大多数情况下，这个类就是一个工具类
+         */
+        int[] arr={7,6,78,1,689,87,165,7,4,5,8};
+        //使用工具类对数组进行排序
+        Arrays.sort(arr);
+
+        //输出arr数组--Arrays.toString方法 是直接把arr数组转换成字符串
+        System.out.println(Arrays.toString(arr));
+        // 拷贝（扩展长度，多余补 0）   -- 把一个数组 的元素 复制到一个新的数组并指定新数组的长度，多余补 0
+        int[] copy = Arrays.copyOf(arr, 10);
+        System.out.println(Arrays.toString(copy));
+        // 拷贝指定范围 [1,4)
+        int[] range = Arrays.copyOfRange(arr, 1, 4);
+        System.out.println(Arrays.toString(range));
+        // 二分查找（需先排序），返回 2  --使用二分查找法，查找数组中，是否包含某个元素，如果包含则返回索引值
+        int index = Arrays.binarySearch(arr, 689);
+        System.out.println(index);
+    }
+}

授课代码/c260716/src/Exercises01.java

@@ -0,0 +1,31 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Exercises01
+ * @description 课堂练习01：定义一个整数数组 `{10, 20, 30, 40, 50}`，将数组中第 1 个元素与第 5 个元素交换，
+ * 第 2 个元素与第 4 个元素交换（即首尾对称交换），然后输出交换后的数组。
+ * @create 2026/7/16
+ */
+public class Exercises01 {
+    public static void main(String[] args) {
+        int[] arr={10, 20, 30, 40, 50};
+        System.out.print("交换前：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i]+" ");
+        }
+        System.out.println();
+        System.out.print("交换后：");
+        //首尾交换 第1位和第5位，第2位和第4位
+        arr[0]=arr[0]+arr[4];
+        arr[4]=arr[0]-arr[4];
+        arr[0]=arr[0]-arr[4];
+
+        arr[1]=arr[1]+arr[3];
+        arr[3]=arr[1]-arr[3];
+        arr[1]=arr[1]-arr[3];
+
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i]+" ");
+        }
+    }
+}

授课代码/c260716/src/Exercises02.java

@@ -0,0 +1,81 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Exercises02
+ * @description  课堂练习02：定义一个整数数组 `{1, 2, 3, 4, 5}`，
+ * 将数组中的所有元素向右移动 2 个位置。超出数组范围的元素循环移到数组开头（循环右移）。
+ * @create 2026/7/16
+ */
+public class Exercises02 {
+    public static void main(String[] args) {
+        int[] arr={1, 2, 3, 4, 5};
+        int k= 2; //右移位数
+        //如果k大于数组长度，要取模
+        k=k% arr.length;
+
+        System.out.print("移动前：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i]+" ");
+        }
+        System.out.println();
+        //整体右移k位（循环右移）
+        for (int i = 0; i < k; i++) {
+            //保存最后一个元素
+            int last=arr[arr.length-1];
+            //从后往前，每个元素向后移动1位
+            for (int j = arr.length-1; j>0; j--) {  //循环数组长度的轮数
+                arr[j]=arr[j-1];    //把倒数第2位赋值给最后1位
+            }
+            //把最后1位给第0位
+            arr[0]=last;
+        }
+        System.out.print("移动后：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i]+" ");
+        }
+
+        /*
+            解题思路过程
+            1   2   3   4   5
+
+            先不管移动几位，就只研究 全体向右移动1位。
+
+            1、先把最后一个元素保存起来。
+            2、倒数第2位，赋值给倒数第1位。
+            3、倒数第3位，赋值给倒数第2位。
+            4、倒数第4位，赋值给倒数第3位。
+            5、倒数第5位(第1位)，赋值给倒数第4位。
+            6、把保存起来的最后一个元素，赋值给倒数第5位(第1位)
+
+            //保存最后一个元素
+            int last=arr[arr.length-1];
+
+            整过流程使用循环，就不能是正循环，而是倒着循环， 从 arr[arr.length-1] -> arr[0]
+            所以：
+            for(j=arr.length-1;j>0;j--){
+                //前一个元素赋值给后一个元素
+                arr[j]=arr[j-1];
+            }
+            最后，再把最后一个元素，赋值给第1个元素
+            arr[0]=last;
+
+
+            现在我们再加上 【数组中的所有元素向右移动 20 个位置】
+            定义变量 k 存移动位置
+            在刚刚的移动的代码外，增加一个循环
+            for(int i=0;i<k;i++){   //移动k次
+
+            }
+
+            最后，在代码的最初，增加一行，k=k% arr.length;
+            要解决的就是，如果k大于数组的长度，会出现重复的不必要的移动。
+            比如移动6次，和移动1次，的位置是一样的，
+            移动5次，和不移动是一样。
+            移动7次，和移动2次是一样的。
+
+         */
+
+
+
+    }
+}

授课代码/c260716/src/Exercises03.java

@@ -0,0 +1,49 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Exercises03
+ * @description 定义一个整数数组 `{5, 2, 8, 2, 5, 9, 1, 8, 3}`，去除数组中重复的元素，只保留第一次出现的元素，输出去重后的新数组。
+ * @create 2026/7/16
+ */
+public class Exercises03 {
+    public static void main(String[] args) {
+        /*
+            先统计不重复元素的个数
+         */
+        int[] arr={5, 2, 8, 2, 5, 9, 1, 8, 3};
+        int count=0;    //个数
+        for (int i = 0; i < arr.length; i++) {
+            boolean b=false;    //设置false，表示 先认为当前的数组元素是没有重复的
+            for (int j = 0; j < i; j++) {    //找 arr[i]元素，在arr数组中，有没有重复的元素。
+                if (arr[i]==arr[j]){    //只要找到一个重复的
+                    b=true; //就把b设置为 true
+                    break;  //跳出内层循环
+                }
+            }
+            if (b==false){  //那就说明这个元素是没有重复的，就计数
+                count++;
+            }
+        }
+        //创建的新的数组长度就是 count
+        int[] newArr=new int[count];    //动态初始化
+        int index=0;    //作为新数组的索引值
+        for (int i = 0; i < arr.length; i++) {
+            boolean b=false;    //设置false，表示 先认为当前的数组元素是没有重复的
+            //检查arr[i]在它之前是否有出现过
+            for (int j = 0; j < i; j++) {    //找 arr[i]元素，在arr数组中，有没有重复的元素。
+                if (arr[i]==arr[j]){    //只要找到一个重复的
+                    b=true; //就把b设置为 true
+                    break;  //跳出内层循环
+                }
+            }
+            //判断 如果我们设置的标记还是false，说明
+            if (b==false){  //那就说明这个元素是没有重复的，就放进新的数组
+                newArr[index]=arr[i];
+                index++;
+            }
+        }
+        for (int i = 0; i < newArr.length; i++) {
+            System.out.print(newArr[i]+" ");
+        }
+    }
+}

授课代码/c260716/src/HomeWork07.java

@@ -0,0 +1,18 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork07
+ * @description 7月15日作业：定义一个整数数组 `{11, 22, 33, 44, 55}`，使用 `for` 循环遍历数组，计算所有元素的总和并输出。
+ * @create 2026/7/16
+ */
+public class HomeWork07 {
+    public static void main(String[] args) {
+        int[] arr={11, 22, 33, 44, 55};
+        int sum=0;  //用来记录累加和
+        for (int i = 0; i < arr.length; i++) {
+            // 通过arr[i] 获取到每一个数组元素，然后累加到sum
+            sum+=arr[i];
+        }
+        System.out.println(sum);
+    }
+}

授课代码/c260716/src/HomeWork08.java

@@ -0,0 +1,19 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork08
+ * @description 7月15日作业：定义一个整数数组 `{3, 8, 1, 9, 4, 7, 2}`，找出数组中的最大值并输出。
+ * @create 2026/7/16
+ */
+public class HomeWork08 {
+    public static void main(String[] args) {
+        int[] arr={3, 8, 1, 9, 4, 7, 2};
+        int max=arr[0];  //作为最大值
+        for (int i = 1; i < arr.length; i++) {
+            if(arr[i]>max){ //如果某个元素比最大值max还大
+                max=arr[i]; //就把这个值赋值给max
+            }
+        }
+        System.out.println(max);
+    }
+}

授课代码/c260716/src/HomeWork09.java

@@ -0,0 +1,16 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork09
+ * @description 7月15日作业：定义一个整数数组 `{1, 2, 3, 4, 5}`，从后往前遍历数组，将元素倒序输出。
+ * @create 2026/7/16
+ */
+public class HomeWork09 {
+    public static void main(String[] args) {
+        int[]arr={1, 2, 3, 4, 5};
+        // for循环的初始化语句，从数组元素索引值的最大值开始，到索引值为0结束，每次递减1
+        for (int i = arr.length-1; i >=0; i--) {
+            System.out.println(arr[i]);
+        }
+    }
+}

授课代码/c260716/src/HomeWork10.java

@@ -0,0 +1,21 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork10
+ * @description  7月15日作业：定义一个整数数组 `{12, 7, 9, 24, 15, 8, 31, 46}`，遍历数组，统计其中奇数和偶数的个数。
+ * @create 2026/7/16
+ */
+public class HomeWork10 {
+    public static void main(String[] args) {
+        int[] arr={12, 7, 9, 24, 15, 8, 31, 46};
+        int count=0;    //作为奇数个数
+        //遍历数组
+        for (int i = 0; i < arr.length; i++) {
+            //如果某个数组元素余2不等于0，就说明是奇数
+            if (arr[i]%2!=0){
+                count++;    //就累加1
+            }
+        }
+        System.out.println("奇数个数："+count+"，偶数个数："+(arr.length-count));
+    }
+}

课堂笔记/01-JavaSE基础-笔记/20260716-笔记.md

@@ -0,0 +1,915 @@
+# JavaSE 基础 — Day04 笔记
+
+> **日期**：2026-07-16  
+> **项目**：`c260716`  
+> **作者**：WanJL
+
+---
+
+## 一、多维数组
+
+### 1. 多维数组概述
+
+Java 中的多维数组本质上是**数组的数组**：
+
+| 维度 | 本质 | 说明 |
+|------|------|------|
+| **一维数组** | 元素是数据类型的变量或常量 | `int[]` → 元素是 `int` |
+| **二维数组** | 元素是一维数组 | `int[][]` → 元素是 `int[]` |
+| **三维数组** | 元素是二维数组 | `int[][][]` → 元素是 `int[][]` |
+
+> **核心概念**：二维数组的每个元素其实是一维数组的**引用地址值**。
+
+#### 二维数组的定义格式
+
+```java
+数组类型[][] 数组名 = new 数组类型[二维数组长度][一维数组长度];
+// 示例：3行2列的二维数组
+int[][] arr = new int[3][2];  // [行数][列数]
+```
+
+---
+
+### 2. 二维数组的遍历
+
+二维数组需要**两层循环嵌套**来遍历：
+
+```java
+// 外层循环控制行数（二维数组的长度）
+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();
+}
+```
+
+- `arr.length` — 二维数组的长度（即行数）
+- `arr[i].length` — 第 i 行一维数组的长度（即列数）
+
+---
+
+### 3. 二维数组的静态初始化
+
+```java
+int[][] arr1 = {
+    {1, 2, 3},
+    {4, 5, 6},
+    {7, 8, 9}
+};
+```
+
+---
+
+### 4. 不规则的二维数组（每个一维数组长度不同）
+
+二维数组中的一维数组**不必长度相同**：
+
+```java
+int[] arr01 = {1, 3};
+int[] arr02 = {4, 5, 6};
+int[] arr03 = {7, 8, 9, 15};
+int[][] arr2 = {arr01, arr02, arr03};  // 存放的是一维数组的引用地址
+```
+
+遍历时同样使用两层循环，每个内层循环以对应一维数组的长度为界：
+
+```java
+for (int i = 0; i < arr2.length; i++) {
+    for (int j = 0; j < arr2[i].length; j++) {
+        System.out.print(arr2[i][j] + " ");
+    }
+    System.out.println();
+}
+```
+
+---
+
+## 二、增强 for 循环（foreach）
+
+### 1. foreach 概述
+
+**增强 for 循环（foreach）** 是 Java 提供的一种简化数组遍历的语法，作用和普通 `for` 循环一样，主要用于**遍历数组或集合中的所有元素**。
+
+#### 语法格式
+
+```java
+for (数据类型 变量 : 数组名) {
+    代码块
+}
+```
+
+#### 基本示例
+
+```java
+int[] arr = {1, 2, 3, 4, 5, 6, 8};
+for (int a : arr) {
+    System.out.print(a + " ");
+}
+// 输出：1 2 3 4 5 6 8
+```
+
+> ⚠️ **注意**：foreach 遍历数组时**无法获取索引值**，所以只适合**遍历全部元素**。如果需要操作某个指定索引位置的元素，仍需使用普通 `for` 循环。
+
+---
+
+### 2. foreach 遍历二维数组
+
+```java
+int[] arr01 = {1, 3};
+int[] arr02 = {4, 5, 6};
+int[] arr03 = {7, 8, 9, 15};
+int[][] arr2 = {arr01, arr02, arr03};
+
+for (int[] a : arr2) {    // 外层 foreach：遍历二维数组，得到每个一维数组
+    for (int a1 : a) {    // 内层 foreach：遍历一维数组，得到每个元素
+        System.out.print(a1 + " ");
+    }
+    System.out.println();
+}
+```
+
+> 外层 `int[] a` 表示二维数组中的每个元素是一维数组，内层 `int a1` 表示一维数组中的每个元素是 `int`。
+
+---
+
+### 3. for 循环 vs foreach 对比
+
+| 特性 | 普通 for 循环 | 增强 for 循环（foreach） |
+|------|-------------|------------------------|
+| **语法** | `for(int i=0; i<len; i++)` | `for(int a : arr)` |
+| **索引访问** | 支持（通过 `i`） | 不支持 |
+| **适用场景** | 需要索引、修改元素、部分遍历 | 只需要遍历全部元素 |
+| **代码简洁性** | 较繁琐 | 更简洁 |
+| **可读性** | 一般 | 更好 |
+
+---
+
+## 三、数组工具类 `java.util.Arrays`
+
+### 1. 概述
+
+`java.util.Arrays` 是 Java 提供的**数组工具类**，包含大量操作数组的静态方法。
+
+> **命名特点**：如果一个类的类名是**名词 + `s`**，大多数情况下这个类就是**工具类**。
+
+**使用前提**：需要导包
+
+```java
+import java.util.Arrays;
+// import 是导包的关键字，后面跟着【类全路径名】—— 包名.类名
+```
+
+---
+
+### 2. 常用方法
+
+| 方法 | 作用 | 示例 |
+|------|------|------|
+| `Arrays.sort(arr)` | 对数组进行**升序排序** | `Arrays.sort(arr);` |
+| `Arrays.toString(arr)` | 将数组转换为**字符串**输出 | `System.out.println(Arrays.toString(arr));` |
+| `Arrays.copyOf(arr, newLength)` | **拷贝数组**（扩展或截断，多余补默认值） | `int[] copy = Arrays.copyOf(arr, 10);` |
+| `Arrays.copyOfRange(arr, from, to)` | 拷贝数组的**指定范围** `[from, to)` | `int[] range = Arrays.copyOfRange(arr, 1, 4);` |
+| `Arrays.binarySearch(arr, key)` | **二分查找**（数组必须先排序），返回索引值（未找到返回负数） | `int index = Arrays.binarySearch(arr, 689);` |
+
+#### 详细示例
+
+```java
+int[] arr = {7, 6, 78, 1, 689, 87, 165, 7, 4, 5, 8};
+
+// 排序
+Arrays.sort(arr);
+System.out.println(Arrays.toString(arr));
+// 输出：[1, 4, 5, 6, 7, 7, 8, 78, 87, 165, 689]
+
+// 拷贝（扩展长度，多余补 0）
+int[] copy = Arrays.copyOf(arr, 10);
+System.out.println(Arrays.toString(copy));
+
+// 拷贝指定范围 [1, 4) — 包含索引1，不包含索引4
+int[] range = Arrays.copyOfRange(arr, 1, 4);
+System.out.println(Arrays.toString(range));  // 输出：[4, 5, 6]
+
+// 二分查找（需先排序），返回元素在数组中的索引
+int index = Arrays.binarySearch(arr, 689);
+System.out.println(index);  // 输出：10（排序后 689 在索引 10）
+```
+
+> ⚠️ `Arrays.binarySearch()` 要求数组**必须先排序**，否则结果不确定。
+
+---
+
+## 四、课堂练习详解
+
+### 练习 01：首尾对称交换数组元素
+
+**题目**：定义数组 `{10, 20, 30, 40, 50}`，将第 1 个与第 5 个交换、第 2 个与第 4 个交换（首尾对称交换）。
+
+**核心思路**：使用**加减法交换**（不借助第三个变量）实现两个位置的元素互换。
+
+```java
+int[] arr = {10, 20, 30, 40, 50};
+
+// 首尾交换：第1位和第5位
+arr[0] = arr[0] + arr[4];
+arr[4] = arr[0] - arr[4];
+arr[0] = arr[0] - arr[4];
+
+// 首尾交换：第2位和第4位
+arr[1] = arr[1] + arr[3];
+arr[3] = arr[1] - arr[3];
+arr[1] = arr[1] - arr[3];
+```
+
+**变量交换的三种方式**：
+
+| 方式 | 代码 | 优点 | 缺点 |
+|------|------|------|------|
+| **借助临时变量** | `tmp = a; a = b; b = tmp;` | 直观、安全 | 多用一个变量 |
+| **加减法交换** | `a = a + b; b = a - b; a = a - b;` | 无需额外变量 | 可能溢出（大数） |
+| **异或交换** | `a = a ^ b; b = a ^ b; a = a ^ b;` | 无需额外变量 | 可读性差 |
+
+---
+
+### 练习 02：数组循环右移
+
+**题目**：定义数组 `{1, 2, 3, 4, 5}`，将数组中的所有元素向右移动 2 个位置，超出数组范围的元素循环移到数组开头。
+
+**解题思路**：
+
+先理解**全体向右移动 1 位**的过程：
+1. 先把最后一个元素保存起来
+2. 倒数第 2 位 → 倒数第 1 位
+3. 倒数第 3 位 → 倒数第 2 位
+4. ...依此类推...
+5. 第 1 位（索引 0）→ 第 2 位（索引 1）
+6. 把保存起来的最后一个元素 → 第 1 位（索引 0）
+
+**执行步骤图解**（右移 1 位）：
+```
+原始： [1, 2, 3, 4, 5]
+第1步：保存最后一个元素 last = 5
+第2步：从后往前移动 ←
+       [1, 2, 3, 4, 4]   // arr[4]=arr[3]
+       [1, 2, 3, 3, 4]   // arr[3]=arr[2]
+       [1, 2, 2, 3, 4]   // arr[2]=arr[1]
+       [1, 1, 2, 3, 4]   // arr[1]=arr[0]
+第3步：arr[0] = last
+结果： [5, 1, 2, 3, 4]
+```
+
+**代码实现**：
+
+```java
+int[] arr = {1, 2, 3, 4, 5};
+int k = 2;  // 右移位数
+
+// 如果k大于数组长度，取模（移动6次 = 移动1次）
+k = k % arr.length;
+
+// 整体右移k位（循环右移）
+for (int i = 0; i < k; i++) {
+    // 保存最后一个元素
+    int last = arr[arr.length - 1];
+    // 从后往前，每个元素向后移动1位
+    for (int j = arr.length - 1; j > 0; j--) {
+        arr[j] = arr[j - 1];
+    }
+    // 把最后一个元素放到第0位
+    arr[0] = last;
+}
+```
+
+> **关键点**：
+> - 内层循环必须**从后往前**遍历（`j = length-1` → `j > 0`），否则前面的值会被覆盖
+> - `k = k % arr.length` 解决 k 大于数组长度时的重复移动问题（如移动 6 次 = 移动 1 次）
+
+---
+
+### 练习 03：数组去重
+
+**题目**：定义数组 `{5, 2, 8, 2, 5, 9, 1, 8, 3}`，去除重复元素，只保留第一次出现的元素，输出去重后的新数组。
+
+**核心思路**：
+1. **第一步**：统计不重复元素的个数
+2. **第二步**：创建新数组（长度为统计结果）
+3. **第三步**：将不重复元素放入新数组
+
+**判断元素是否重复的方式**：检查当前元素 `arr[i]` 在它**之前**是否出现过（即 `arr[0]` ~ `arr[i-1]` 中是否有相同的值）。
+
+```java
+int[] arr = {5, 2, 8, 2, 5, 9, 1, 8, 3};
+int count = 0;  // 不重复元素的个数
+
+// 第一步：统计不重复元素的个数
+for (int i = 0; i < arr.length; i++) {
+    boolean b = false;  // 标记：先认为当前元素没有重复
+    for (int j = 0; j < i; j++) {  // 检查 arr[i] 在它之前是否出现过
+        if (arr[i] == arr[j]) {
+            b = true;   // 找到重复，标记改为 true
+            break;      // 跳出内层循环
+        }
+    }
+    if (b == false) {   // 没有重复，计数
+        count++;
+    }
+}
+
+// 第二步：创建新数组
+int[] newArr = new int[count];
+int index = 0;  // 新数组的索引
+
+// 第三步：将不重复元素放入新数组
+for (int i = 0; i < arr.length; i++) {
+    boolean b = false;
+    for (int j = 0; j < i; j++) {
+        if (arr[i] == arr[j]) {
+            b = true;
+            break;
+        }
+    }
+    if (b == false) {           // 不重复的元素
+        newArr[index] = arr[i]; // 放入新数组
+        index++;
+    }
+}
+
+// 输出新数组
+for (int i = 0; i < newArr.length; i++) {
+    System.out.print(newArr[i] + " ");
+}
+// 输出：5 2 8 9 1 3
+```
+
+> **核心技巧**：
+> - 使用**布尔标记 `boolean b`** 来判断元素是否重复
+> - 内层循环 `j < i` 只检查当前元素**之前**的元素，确保只保留第一次出现的元素
+> - 两步走：先统计个数 → 再填充数据（因为数组长度在创建后不可改变）
+
+---
+
+## 五、课后作业讲解（7月15日作业）
+
+### 作业 07：数组元素求和
+
+**题目**：定义数组 `{11, 22, 33, 44, 55}`，用 `for` 循环遍历数组，计算所有元素的总和。
+
+**知识点**：数组遍历、累加求和
+
+```java
+int[] arr = {11, 22, 33, 44, 55};
+int sum = 0;  // 记录累加和
+for (int i = 0; i < arr.length; i++) {
+    sum += arr[i];  // 通过 arr[i] 获取每个元素，累加到 sum
+}
+System.out.println(sum);  // 输出：165
+```
+
+---
+
+### 作业 08：找数组最大值
+
+**题目**：定义数组 `{3, 8, 1, 9, 4, 7, 2}`，找出数组中的最大值。
+
+**知识点**：数组遍历、打擂法（假设法）
+
+```java
+int[] arr = {3, 8, 1, 9, 4, 7, 2};
+int max = arr[0];  // 先假设第一个元素是最大值
+for (int i = 1; i < arr.length; i++) {
+    if (arr[i] > max) {  // 如果有元素比当前最大值还大
+        max = arr[i];    // 更新最大值
+    }
+}
+System.out.println(max);  // 输出：9
+```
+
+> **打擂法核心思路**：先假设第一个元素是最大值，然后遍历数组，遇到更大的就更新。
+
+---
+
+### 作业 09：数组倒序输出
+
+**题目**：定义数组 `{1, 2, 3, 4, 5}`，从后往前遍历，将元素倒序输出。
+
+**知识点**：for 循环逆序遍历
+
+```java
+int[] arr = {1, 2, 3, 4, 5};
+// 从最大索引开始，递减到 0
+for (int i = arr.length - 1; i >= 0; i--) {
+    System.out.println(arr[i]);
+}
+// 输出：
+// 5
+// 4
+// 3
+// 2
+// 1
+```
+
+> 从 `arr.length - 1`（最后一个元素的索引）开始，到 `0`（第一个元素的索引）结束，每次递减 1。
+
+---
+
+### 作业 10：统计奇偶数个数
+
+**题目**：定义数组 `{12, 7, 9, 24, 15, 8, 31, 46}`，遍历数组，统计奇数和偶数的个数。
+
+**知识点**：数组遍历、取模判断、统计计数
+
+```java
+int[] arr = {12, 7, 9, 24, 15, 8, 31, 46};
+int count = 0;  // 奇数个数
+for (int i = 0; i < arr.length; i++) {
+    if (arr[i] % 2 != 0) {  // 余2不等于0，说明是奇数
+        count++;
+    }
+}
+System.out.println("奇数个数：" + count + "，偶数个数：" + (arr.length - count));
+// 输出：奇数个数：4，偶数个数：4
+```
+
+> **偶数的判定**：`arr[i] % 2 == 0`  
+> **奇数的判定**：`arr[i] % 2 != 0`  
+> 偶数个数 = 数组总长度 - 奇数个数
+
+---
+
+## 六、随堂练习要点
+
+1. **多维数组本质**：数组的数组，二维数组的元素是一维数组的引用地址
+2. **二维数组定义**：`int[][] arr = new int[3][2];`（3 行 2 列）
+3. **二维数组遍历**：两层循环嵌套，外层行数 `arr.length`，内层列数 `arr[i].length`
+4. **不规则二维数组**：每个一维数组长度可以不同
+5. **foreach 语法**：`for(数据类型 变量 : 数组名) { }`，适合遍历全部元素
+6. **foreach 局限性**：无法获取索引值，无法修改元素，只能读取
+7. **Arrays 工具类**：`java.util.Arrays`，操作数组的静态方法集合
+8. **`Arrays.sort(arr)`**：对数组进行升序排序
+9. **`Arrays.toString(arr)`**：将数组转换为字符串输出
+10. **`Arrays.copyOf(arr, n)`**：拷贝数组，指定新长度，多余补默认值
+11. **`Arrays.copyOfRange(arr, from, to)`**：拷贝指定范围 [from, to)
+12. **`Arrays.binarySearch(arr, key)`**：二分查找（必须先排序）
+13. **变量交换-临时变量法**：`tmp = a; a = b; b = tmp;`
+14. **变量交换-加减法**：`a = a + b; b = a - b; a = a - b;`
+15. **首尾交换**：利用对称性，第 i 位与第 length-1-i 位交换
+16. **循环右移**：从后往前逐个移动，保存最后一个元素放到开头
+17. **取模优化**：`k = k % arr.length` 解决 k 大于数组长度的问题
+18. **数组去重思路**：统计不重复个数 → 创建新数组 → 填充不重复元素
+19. **布尔标记法**：使用 `boolean` 变量标记元素是否重复
+20. **打擂法找最大值**：假设第一个是最大值，遇到更大的就更新
+21. **数组求和**：遍历数组，累加每个元素
+22. **倒序输出**：从 `length-1` 到 `0` 递减遍历
+23. **奇偶判断**：`n % 2 == 0` 偶，`n % 2 != 0` 奇
+
+---
+
+## 七、知识拓展
+
+### 1. 数组的地址值
+
+当直接打印数组变量时，输出的是数组在堆内存中的**地址值**：
+
+```java
+int[] a = new int[10];
+System.out.println(a);  // 输出类似：[I@b4c966a
+```
+
+地址值含义：
+- `[` — 一维数组
+- `I` — 元素类型为 int
+- `@` — 分隔符
+- `b4c966a` — 堆内存中的十六进制地址
+
+### 2. 二维数组的内存结构
+
+```
+二维数组 arr2 = {arr01, arr02, arr03} 在内存中：
+┌──────────┐
+│ arr2[0]  │────→ arr01: [1, 3]
+├──────────┤
+│ arr2[1]  │────→ arr02: [4, 5, 6]
+├──────────┤
+│ arr2[2]  │────→ arr03: [7, 8, 9, 15]
+└──────────┘
+```
+
+二维数组的每个元素存储的是**一维数组的引用地址**，而不是元素本身。
+
+### 3. 二分查找原理
+
+`Arrays.binarySearch()` 基于**二分查找算法**（Binary Search）：
+
+- **前提**：数组必须已排序
+- **原理**：每次将查找范围缩小一半，与中间元素比较
+- **时间复杂度**：O(log n) — 效率远高于线性查找 O(n)
+
+```
+已排序数组：[1, 4, 5, 6, 7, 7, 8, 78, 87, 165, 689]
+查找目标：689
+
+第1次：比较中间元素 7 → 689 > 7，在右半部分查找
+第2次：比较中间元素 87 → 689 > 87，继续在右半部分查找
+第3次：比较中间元素 165 → 689 > 165，继续在右半部分查找
+第4次：找到 689，返回索引 10
+```
+
+### 4. 数组拷贝的深浅问题
+
+`Arrays.copyOf()` 和 `Arrays.copyOfRange()` 执行的是**浅拷贝**：
+
+- 对于基本数据类型：拷贝的是值，互不影响 ✓
+- 对于引用数据类型：拷贝的是引用地址，新数组和原数组指向同一个对象 ⚠️
+
+---
+
+## 八、完整代码汇总
+
+### Demo01.java — 多维数组
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 多维数组
+ * @create 2026/7/16
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        /*
+            一维数组中所有的元素都是数据类型的变量或常量
+            二维数组中所有的元素都是一维数组
+            三维数组中所有的元素都是二维数组
+            ......
+
+            Java多维数组的本质：其实就是数组的数组，二维数组的元素其实就是一维数组的引用地址值
+
+            二维数组的定义的格式：
+            数组类型[][] 数组名=new 数组类型[二维数组长度][一维数组长度];
+         */
+        //数组类型[][] 数组名=new 数组类型[二维数组长度][一维数组长度];
+        int[][] arr = new int[3][2];  //[行数][列数]
+
+        //遍历二维数组需要两层循环嵌套
+        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();
+        }
+        // 静态初始化二维数组----三行三列
+        int[][] arr1 = {
+                {1, 2, 3},
+                {4, 5, 6},
+                {7, 8, 9}
+        };
+        for (int i = 0; i < arr1.length; i++) {
+            for (int j = 0; j < arr1[i].length; j++) {
+                System.out.print(arr1[i][j] + " ");
+            }
+            System.out.println();
+        }
+
+        // 二维数组中的一维数组，不是必须要相同长度的，长度是不一样的。
+        int[] arr01 = {1, 3};
+        int[] arr02 = {4, 5, 6};
+        int[] arr03 = {7, 8, 9, 15};
+        int[][] arr2 = {arr01, arr02, arr03}; //二维数组存放的其实就是一维数组的引用地址
+        for (int i = 0; i < arr2.length; i++) {
+            for (int j = 0; j < arr2[i].length; j++) {
+                System.out.print(arr2[i][j] + " ");
+            }
+            System.out.println();
+        }
+    }
+}
+```
+
+### Demo02.java — foreach 增强 for 循环
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description foreach迭代-增强for循环
+ * @create 2026/7/16
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        //我们之前使用的for循环，是for(int i=0;i<10;i++)
+        //可以使用增强for循环--foreach，作用和for循环一样
+        //主要是用来进行数组遍历
+        /*
+            格式：
+                for(数据类型 变量 : 数组名){
+                    代码块
+                }
+         */
+        int[] arr = {1, 2, 3, 4, 5, 6, 8};
+        for (int a : arr) {
+            System.out.print(a + " ");
+        }
+        System.out.println();
+        /*
+            foreach 遍历的数组，无法获取索引值，所以只适合遍历全部元素。想要获取某个索引位置的元素，需要for循环
+         */
+
+        int[] arr01 = {1, 3};
+        int[] arr02 = {4, 5, 6};
+        int[] arr03 = {7, 8, 9, 15};
+        int[][] arr2 = {arr01, arr02, arr03};
+        for (int[] a : arr2) { //外层foreach
+            for (int a1 : a) { //内层foreach
+                System.out.print(a1 + " ");
+            }
+            System.out.println();
+        }
+    }
+}
+```
+
+### Demo03.java — Arrays 数组工具类
+
+```java
+import java.util.Arrays;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description 数组工具类 ： java.util.Arrays;
+ * @create 2026/7/16
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        /*
+            数组工具类 ： java.util.Arrays;
+            java中的命名特点，如果一个类的类名 是名词+s，那么大多数情况下，这个类就是一个工具类
+         */
+        int[] arr = {7, 6, 78, 1, 689, 87, 165, 7, 4, 5, 8};
+        //使用工具类对数组进行排序
+        Arrays.sort(arr);
+
+        //输出arr数组--Arrays.toString方法 是直接把arr数组转换成字符串
+        System.out.println(Arrays.toString(arr));
+        // 拷贝（扩展长度，多余补 0）-- 把一个数组的元素复制到一个新的数组并指定新数组的长度，多余补 0
+        int[] copy = Arrays.copyOf(arr, 10);
+        System.out.println(Arrays.toString(copy));
+        // 拷贝指定范围 [1,4)
+        int[] range = Arrays.copyOfRange(arr, 1, 4);
+        System.out.println(Arrays.toString(range));
+        // 二分查找（需先排序），返回索引值
+        int index = Arrays.binarySearch(arr, 689);
+        System.out.println(index);
+    }
+}
+```
+
+### Exercises01.java — 首尾对称交换
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Exercises01
+ * @description 课堂练习01：首尾对称交换数组元素
+ * @create 2026/7/16
+ */
+public class Exercises01 {
+    public static void main(String[] args) {
+        int[] arr = {10, 20, 30, 40, 50};
+        System.out.print("交换前：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i] + " ");
+        }
+        System.out.println();
+        System.out.print("交换后：");
+        //首尾交换 第1位和第5位，第2位和第4位
+        arr[0] = arr[0] + arr[4];
+        arr[4] = arr[0] - arr[4];
+        arr[0] = arr[0] - arr[4];
+
+        arr[1] = arr[1] + arr[3];
+        arr[3] = arr[1] - arr[3];
+        arr[1] = arr[1] - arr[3];
+
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i] + " ");
+        }
+    }
+}
+```
+
+### Exercises02.java — 数组循环右移
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Exercises02
+ * @description 课堂练习02：数组循环右移
+ * @create 2026/7/16
+ */
+public class Exercises02 {
+    public static void main(String[] args) {
+        int[] arr = {1, 2, 3, 4, 5};
+        int k = 2; //右移位数
+        //如果k大于数组长度，要取模
+        k = k % arr.length;
+
+        System.out.print("移动前：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i] + " ");
+        }
+        System.out.println();
+        //整体右移k位（循环右移）
+        for (int i = 0; i < k; i++) {
+            //保存最后一个元素
+            int last = arr[arr.length - 1];
+            //从后往前，每个元素向后移动1位
+            for (int j = arr.length - 1; j > 0; j--) {
+                arr[j] = arr[j - 1];
+            }
+            //把最后1位给第0位
+            arr[0] = last;
+        }
+        System.out.print("移动后：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i] + " ");
+        }
+    }
+}
+```
+
+### Exercises03.java — 数组去重
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Exercises03
+ * @description 课堂练习03：数组去重
+ * @create 2026/7/16
+ */
+public class Exercises03 {
+    public static void main(String[] args) {
+        /*
+            先统计不重复元素的个数
+         */
+        int[] arr = {5, 2, 8, 2, 5, 9, 1, 8, 3};
+        int count = 0;    //个数
+        for (int i = 0; i < arr.length; i++) {
+            boolean b = false;    //设置false，表示先认为当前的数组元素是没有重复的
+            for (int j = 0; j < i; j++) {    //找 arr[i]元素，在arr数组中，有没有重复的元素。
+                if (arr[i] == arr[j]) {    //只要找到一个重复的
+                    b = true; //就把b设置为 true
+                    break;  //跳出内层循环
+                }
+            }
+            if (b == false) {  //那就说明这个元素是没有重复的，就计数
+                count++;
+            }
+        }
+        //创建的新的数组长度就是 count
+        int[] newArr = new int[count];    //动态初始化
+        int index = 0;    //作为新数组的索引值
+        for (int i = 0; i < arr.length; i++) {
+            boolean b = false;    //设置false，表示先认为当前的数组元素是没有重复的
+            //检查arr[i]在它之前是否有出现过
+            for (int j = 0; j < i; j++) {
+                if (arr[i] == arr[j]) {
+                    b = true;
+                    break;
+                }
+            }
+            //判断如果我们设置的标记还是false，说明没有重复
+            if (b == false) {
+                newArr[index] = arr[i];
+                index++;
+            }
+        }
+        for (int i = 0; i < newArr.length; i++) {
+            System.out.print(newArr[i] + " ");
+        }
+    }
+}
+```
+
+### HomeWork07.java — 数组求和
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork07
+ * @description 7月15日作业：数组元素求和
+ * @create 2026/7/16
+ */
+public class HomeWork07 {
+    public static void main(String[] args) {
+        int[] arr = {11, 22, 33, 44, 55};
+        int sum = 0;
+        for (int i = 0; i < arr.length; i++) {
+            sum += arr[i];
+        }
+        System.out.println(sum);
+    }
+}
+```
+
+### HomeWork08.java — 找数组最大值
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork08
+ * @description 7月15日作业：找数组最大值
+ * @create 2026/7/16
+ */
+public class HomeWork08 {
+    public static void main(String[] args) {
+        int[] arr = {3, 8, 1, 9, 4, 7, 2};
+        int max = arr[0];  //假设第一个元素是最大值
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[i] > max) {
+                max = arr[i];
+            }
+        }
+        System.out.println(max);
+    }
+}
+```
+
+### HomeWork09.java — 数组倒序输出
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork09
+ * @description 7月15日作业：数组倒序输出
+ * @create 2026/7/16
+ */
+public class HomeWork09 {
+    public static void main(String[] args) {
+        int[] arr = {1, 2, 3, 4, 5};
+        for (int i = arr.length - 1; i >= 0; i--) {
+            System.out.println(arr[i]);
+        }
+    }
+}
+```
+
+### HomeWork10.java — 统计奇偶数个数
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork10
+ * @description 7月15日作业：统计奇偶数个数
+ * @create 2026/7/16
+ */
+public class HomeWork10 {
+    public static void main(String[] args) {
+        int[] arr = {12, 7, 9, 24, 15, 8, 31, 46};
+        int count = 0;    //奇数个数
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i] % 2 != 0) {
+                count++;
+            }
+        }
+        System.out.println("奇数个数：" + count + "，偶数个数：" + (arr.length - count));
+    }
+}
+```
+
+---
+
+## 九、拓展阅读
+
+| 概念 | 说明 |
+|------|------|
+| **多维数组** | Java 中多维数组是数组的数组，二维数组的元素是一维数组的引用地址 |
+| **二维数组遍历** | 外层循环遍历行（`arr.length`），内层循环遍历列（`arr[i].length`） |
+| **不规则数组** | 二维数组中的每个一维数组长度可以不同 |
+| **增强 for 循环** | `for(类型 变量 : 数组)` 语法，简化数组/集合遍历，无法获取索引 |
+| **Arrays 工具类** | `java.util.Arrays` 包含 sort、toString、copyOf、binarySearch 等静态方法 |
+| **Arrays.sort()** | 对数组进行快速排序（Dual-Pivot Quicksort） |
+| **Arrays.toString()** | 将数组转换为可读的字符串格式 `[elem1, elem2, ...]` |
+| **Arrays.copyOf()** | 数组拷贝，可指定新长度，扩展部分补默认值，截断部分丢弃 |
+| **Arrays.copyOfRange()** | 拷贝数组指定范围 `[from, to)`，包含 from 不包含 to |
+| **Arrays.binarySearch()** | 二分查找，数组必须先排序，返回索引值（未找到返回负数） |
+| **变量交换-临时变量** | `tmp = a; a = b; b = tmp;` 最直观的交换方式 |
+| **变量交换-加减法** | `a = a + b; b = a - b; a = a - b;` 不借助第三个变量 |
+| **数组循环右移** | 从后往前逐位移动，保存最后一位到第一位，外层套循环控制移动次数 |
+| **数组去重** | 两层循环 + 布尔标记，检查当前元素在它之前是否出现过 |
+| **打擂法** | 先假设第一个是最大值/最小值，遍历数组遇到更值就更新 |
+| **数组求和** | `sum += arr[i]` 遍历累加 |
+| **倒序遍历** | `for (int i = length-1; i >= 0; i--)` |
+| **奇偶判断** | `n % 2 == 0` 为偶数，`n % 2 != 0` 为奇数 |
+| **取模优化** | 对循环移动的位数取模，避免无效重复移动 |

课堂练习题/20260715-数组进阶练习.md

@@ -56,7 +56,9 @@ public class Practice01 {
 }
 ```
 
----### 练习 2：数组元素循环右移
+---
+
+### 练习 2：数组元素循环右移
 
 **难度**：⭐⭐⭐  
 **知识点**：数组操作、循环、下标运算