一、上午学习：数组核心语法 + 内存初步（2.5h）

1. 数组定义与初始化（3 种写法，必背）

知识点

• 数组：长度固定，创建后不能修改
• 索引从0开始，最大索引 = 数组长度 - 1
• 索引越界：ArrayIndexOutOfBoundsException

java

运行

public class ArrayInit {
    public static void main(String[] args) {
        // 1. 动态初始化：指定长度，内容用默认值
        int[] arr1 = new int[5]; 
        // 长度5，默认值 [0,0,0,0,0]

        // 2. 静态初始化：直接赋值，长度自动计算（最常用）
        int[] arr2 = {1,2,3,4,5};

        // 3. 标准静态初始化：完整写法
        int[] arr3 = new int[]{10,20,30};

        // 测试输出
        System.out.println("arr1长度：" + arr1.length);
        System.out.println("arr2[0]：" + arr2[0]);
        System.out.println("arr3[2]：" + arr3[2]);
    }
}

---

2. 数组默认值（0.3h）

知识点

• int → 0
• double → 0.0
• boolean → false
• 引用类型 → null

java

运行

public class ArrayDefaultValue {
    public static void main(String[] args) {
        int[] arrInt = new int[3];        // [0,0,0]
        double[] arrDouble = new double[3];// [0.0,0.0,0.0]
        boolean[] arrBool = new boolean[3];// [false,false,false]
        String[] arrStr = new String[3];   // [null,null,null]

        System.out.println(arrInt[0]);     // 0
        System.out.println(arrDouble[0]);  // 0.0
        System.out.println(arrBool[0]);    // false
        System.out.println(arrStr[0]);     // null
    }
}

---

3. 数组遍历（2 种，必熟练）

知识点

• 普通 for：可操作索引（修改、查找、反转）
• 增强 for：只读取元素，代码简洁

java

运行

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

        // 1. 普通for循环（能用索引）
        System.out.println("=== 普通for ===");
        for (int i = 0; i < arr.length; i++) {
            System.out.println("索引" + i + "：" + arr[i]);
        }

        // 2. 增强for/foreach（只遍历值）
        System.out.println("=== 增强for ===");
        for (int num : arr) {
            System.out.println(num);
        }
    }
}

---

4. 内存初步理解（面试重点）

核心知识点（必须背）

1. 栈内存：存基本类型变量、数组引用地址
2. 堆内存：存数组 / 对象的真实数据
3. 两个引用指向同一个数组，修改一个，另一个也变

java

运行

public class ArrayMemory {
    public static void main(String[] args) {
        // 数组对象在堆里，变量a存的是堆的地址
        int[] a = {1, 2};
        // 把a的地址赋值给b，a和b指向同一个数组！
        int[] b = a;

        // 通过b修改数组元素
        b[0] = 100;

        // a也会变！因为指向同一个堆内存
        System.out.println(a[0]); // 100
        System.out.println(b[0]); // 100
    }
}

画图口诀

• 变量名在栈，数组内容在堆
• int[] a = b → 地址赋值，共享数组

---

二、下午学习：数组经典算法（3h）

1. 求数组最值（最大 / 最小）

思路

1. 假设第一个元素是最值
2. 循环比较，遇到更大 / 更小就更新

java

运行

public class ArrayMaxMin {
    public static void main(String[] args) {
        int[] arr = {5, 3, 9, 1, 6};

        // 最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        // 最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }

        System.out.println("最大值：" + max); // 9
        System.out.println("最小值：" + min); // 1
    }
}

---

2. 数组求和、平均值

java

运行

public class ArraySumAvg {
    public static void main(String[] args) {
        // 5个学生成绩
        int[] scores = {80, 90, 75, 85, 95};
        int sum = 0;

        // 求和
        for (int s : scores) {
            sum += s;
        }

        // 平均值（注意转double）
        double avg = sum * 1.0 / scores.length;

        System.out.println("总分：" + sum);    // 425
        System.out.println("平均分：" + avg); // 85.0
    }
}

---

3. 顺序查找（判断元素是否存在）

java

运行

public class ArraySearch {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40};
        int target = 30; // 要找的数
        int index = -1;  // -1代表没找到

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                index = i; // 找到，记录索引
                break;     // 退出循环
            }
        }

        if (index == -1) {
            System.out.println("不存在");
        } else {
            System.out.println("找到了，索引：" + index); // 2
        }
    }
}

---

4. 数组反转（双指针，面试常问）

思想

• 左指针i从 0 开始
• 右指针j从末尾开始
• 交换，然后i++、j--，直到i >= j

java

运行

public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int i = 0, j = arr.length - 1;

        // 双指针交换
        while (i < j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }

        // 打印反转结果：5 4 3 2 1
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

---

5. 冒泡排序（实习必默写）

原理

• 每一轮把最大的数 “冒” 到最后
• 外层循环：控制轮数
• 内层循环：相邻比较交换

java

运行

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3,1,4,2};

        // 外层：轮数 = 长度-1
        for (int i = 0; i < arr.length - 1; i++) {
            // 内层：每轮比较次数，-i是因为后面i个已排好
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 前 > 后，交换（升序）
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        // 输出排序后：1 2 3 4
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

---

三、晚上：综合练习题（1.5h）

必做 5 题（完整代码）

1. 定义数组并遍历

java

运行

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        for(int num : arr){
            System.out.println(num);
        }
    }
}

2. 求最大值、最小值、总和

java

运行

public class Test2 {
    public static void main(String[] args) {
        int[] arr = {10,50,20,5};
        int max = arr[0];
        int min = arr[0];
        int sum = 0;

        for(int num : arr){
            if(num>max) max=num;
            if(num<min) min=num;
            sum += num;
        }
        System.out.println(max);
        System.out.println(min);
        System.out.println(sum);
    }
}

3. 判断数字是否存在

java

运行

public class Test3 {
    public static void main(String[] args) {
        int[] arr = {5,8,2};
        int find = 8;
        boolean exists = false;

        for(int num : arr){
            if(num == find){
                exists = true;
                break;
            }
        }
        System.out.println(exists ? "存在" : "不存在");
    }
}

4. 数组反转

java

运行

public class Test4 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        int i=0,j=arr.length-1;
        while(i<j){
            int t=arr[i]; arr[i]=arr[j]; arr[j]=t;
            i++;j--;
        }
        for(int num:arr) System.out.print(num+" ");
    }
}

5. 冒泡排序

直接用下午的冒泡排序代码即可。

---

扩展题（面试 / 比赛加分）

1. 统计偶数个数

java

运行

public class Ext1 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        int count = 0;
        for(int num : arr){
            if(num % 2 == 0){
                count++;
            }
        }
        System.out.println("偶数个数："+count);
    }
}

2. 数组复制

java

运行

public class Ext2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        int[] copy = new int[arr.length];

        for(int i=0;i<arr.length;i++){
            copy[i] = arr[i];
        }
        // copy和arr是两个独立数组
    }
}

3. 简单数组去重

java

运行

public class Ext3 {
    public static void main(String[] args) {
        int[] arr = {1,2,2,3,3,3};
        int[] temp = new int[arr.length];
        int index = 0;

        for (int i = 0; i < arr.length; i++) {
            boolean flag = true;
            for (int j = 0; j < i; j++) {
                if (arr[i] == arr[j]) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                temp[index++] = arr[i];
            }
        }

        // 输出去重结果
        for (int i = 0; i < index; i++) {
            System.out.print(temp[i] + " ");
        }
    }
}

---

Day4 必须掌握的硬标准（验收清单）

1. 三种数组初始化方式盲写无误
2. 能说出：栈存地址、堆存数据
3. 独立写出：遍历、最值、查找、反转、冒泡排序
4. 知道ArrayIndexOutOfBoundsException是索引越界
5. 代码格式规范、无报错

重点区分：

表格

	栈内存 Stack	堆内存 Heap
放什么	基本类型、引用地址	数组、对象真实内容
大小	小	大
速度	快	慢
生命周期	方法结束就销毁	GC 自动回收
共享	不共享	所有线程共享
异常	StackOverflowError	OutOfMemoryError