Java 学习笔记（基础篇3）

1. 数组：

① 静态初始化：

(1) 格式：

int[] arr = {1, 2, 3};

② 遍历

/* 格式：
数组名.length */
for(int i = 0; i < arr.length; i++){
    //在循环的过程中，i依次表示数组中的每一个索引
    sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}

③ 数组动态初始化

(1) 格式：

int[] arr = new int[3];

④ 练习：

(1) 请编写一个 Java 程序，实现以下功能：

1. 创建一个长度为 10 的整数数组
2. 使用随机数为数组赋值，随机数的范围是 1 到 100（包含 1 和 100）
3. 打印输出数组中的所有元素
4. 计算并输出数组中所有元素的总和
5. 计算并输出数组中所有元素的平均值（取整数部分）
6. 统计并输出数组中比平均值小的元素的个数

public class test4 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        int count = 0;
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int num = r.nextInt(100) + 1;
            arr[i] = num;
            System.out.print(arr[i] + " ");
        }
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("数组中所有数据的和为" + sum);
        int avg = sum / arr.length;
        System.out.println("数组中平均数为" + avg);
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < avg){
                count++;
            }
        }
        System.out.println("在数组中,一共有" + count + "个数据，比平均数小");
    }
}

关键逻辑：

• 计算数组总和：遍历数组，用累加的方式（sum += arr[i]）计算所有元素的总和
• 输出数组元素的行：逐个打印数组中的元素，元素之间用空格分隔，使用 print 而非 println，保证所有元素在同一行输出（例如：35 12 78 ...），而不是每个元素单独占一行。

(2) 交换数据

定义一个包含元素 {1,2,3,4,5} 的整数数组，通过编程将数组中的元素进行反转（即第一个元素与最后一个元素交换位置，第二个元素与倒数第二个元素交换位置，以此类推），最后将反转后的数组元素依次打印输出（元素之间用空格分隔）。

public class test5 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int i = 0, j = arr.length - 1; i < j; i++, 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] + " ");
        }
    }
}

关键逻辑：

1. 双指针对称遍历
   循环中使用两个指针（i 和 j）：

   • i 从数组开头（索引 0）向后移动
   • j 从数组末尾（索引arr.length-1）向前移动
   • 循环条件 i < j 确保只交换前半部分与后半部分的对称元素（避免重复交换）

2. 元素交换实现反转
   在每次循环中：

   • 用临时变量 temp 保存 arr[i] 的值
   • 将 arr[j] 的值赋给 arr[i]（把后半部分元素放到前半部分）
   • 将 temp（原来的 arr[i]）的值赋给 arr[j]（把前半部分元素放到后半部分）
   • 交换后 i 递增、j 递减，继续处理下一对对称元素

2. 方法

① 带参数方法的定义和调用：

(1) 形参和实参：

形参：方法定义中的参数，等同于变量定义格式；
实参：方法调用中的参数，等同于使用变量或常量；

(2) 带返回值方法的定义和调用

public static 返回值类型 方法名() {
    return 数据值;
}

(3) 调用方法时需要注意：

void类型的方法可以直接调用；
非void类型的方法，推荐用变量接收调用；

② 方法的重载

(1) 方法重载（Overloading）：在同一个类中，方法名相同，但参数不同（类型/个数/顺序）。

(2) 特点

• 方法名相同
• 参数不同（个数、类型、顺序）
• 与返回值无关

③ 练习

(1) 数组遍历

请编写一个 Java 程序，实现以下功能：

1. 定义一个 int 类型的数组，数组元素为 {11, 22, 33, 44, 55}
2. 编写一个名为 printArr 的静态方法，该方法接收一个 int 类型数组作为参数
3. printArr 方法需要按照 "[元素 1, 元素 2, 元素 3, ..., 元素 n]" 的格式打印数组内容（注意元素之间用逗号加空格分隔，最后一个元素后没有逗号）
4. 在 main 方法中创建数组并调用 printArr 方法打印数组内容

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

    public static void printArr(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else{
                System.out.print(arr[i] + "," +" ");
            }
        }
        System.out.println("]");
    }
}

关键逻辑：

当执行 printArr(arr)时，并不是把数组的所有元素复制一份传递给方法，而是把arr中存储的首地址传递给了printArr方法的参数arr（方法参数列表中的int[] arr）。

这意味着：

• 方法内部的arr和主方法中的arr指向同一块内存空间（同一个数组）。
• 所以在printArr方法中，通过arr[i]可以访问到数组的所有元素 —— 因为拿到了首地址，就能顺藤找到后续所有元素（数组是连续存储的）。