第一部分：数组基础概念

数组是存储固定大小同类型元素的顺序集合

学习目标

  • 理解数组的内存结构
  • 掌握数组的声明语法
  • 区分数组长度与元素索引

内存结构

数组在内存中是连续的空间，每个元素占用相同大小的内存

10
20
30
40
50
[0] [1] [2] [3] [4]

关键特点

  • 固定长度：创建后长度不可变
  • 同类型元素：所有元素必须是相同数据类型
  • 索引访问：通过索引(0开始)快速访问任意元素
  • 连续内存：元素在内存中连续存储

第二部分：数组声明与初始化

掌握多种数组创建方式及初始化技巧

1

声明数组

语法格式：

// 推荐方式
int[] numbers; // 声明整数数组
String[] names; // 声明字符串数组
double[] prices; // 声明双精度数组

// 不推荐（C风格）
int numbers2[];
2

初始化方式

方式一：动态初始化（指定长度）

// 创建长度为5的整型数组，默认值为0
int[] scores = new int[5];

// 创建长度为3的字符串数组，默认值为null
String[] cities = new String[3];

方式二：静态初始化（指定元素值）

// 完整写法
int[] ages = new int[] {18, 25, 30, 22};

// 简化写法（推荐）
int[] ages2 = {18, 25, 30, 22};

String[] names = {"Alice", "Bob", "Charlie"};

常见错误

错误示例：指定长度同时指定值

// 错误！不能同时指定长度和值
int[] wrong = new int[3] {1, 2, 3}; // 编译错误

第三部分：数组访问与修改

掌握数组元素的读写操作及注意事项

1

访问数组元素

int[] numbers = {10, 20, 30, 40, 50};

// 访问元素
int first = numbers[0]; // 10
int third = numbers[2]; // 30

// 获取数组长度
int length = numbers.length; // 5
2

修改数组元素

String[] fruits = new String[3];
fruits[0] = "Apple";
fruits[1] = "Banana";
fruits[2] = "Orange";

// 修改元素
fruits[1] = "Grapes"; // 将"Banana"改为"Grapes"

数组越界异常

int[] arr = {1, 2, 3};
// 错误：索引3超出范围（有效索引0-2）
int value = arr[3]; // ArrayIndexOutOfBoundsException

第四部分：数组遍历方法

掌握四种常见的数组遍历方式

1

传统for循环

int[] scores = {85, 92, 78, 95, 88};

// 遍历数组
for (int i = 0; i < scores.length; i++) {
    System.out.println("第" + (i + 1) + "个成绩: " + scores[i]);
}

// 计算总和
int sum = 0;
for (int i = 0; i < scores.length; i++) {
    sum += scores[i];
}
System.out.println("总分: " + sum);
2

增强for循环（for-each）

String[] names = {"Alice", "Bob", "Charlie"};

// 增强for循环（只读遍历）
for (String name : names) {
    System.out.println(name);
}

// 计算数组最大值（需要索引时用传统for）
int[] numbers = {3, 7, 2, 9, 1};
int max = numbers[0];
for (int num : numbers) {
    if (num > max) {
        max = num;
    }
}
3

while循环遍历

double[] prices = {19.99, 29.99, 39.99};

int index = 0;
while (index < prices.length) {
    System.out.println("Price $" + prices[index]);
    index++;
}
4

Arrays工具类遍历

import java.util.Arrays;

int[] data = {5, 3, 8, 1, 4};

// 转换为字符串输出
System.out.println(Arrays.toString(data));
// 输出: [5, 3, 8, 1, 4]

// 排序后遍历
Arrays.sort(data);
System.out.println("排序后: " + Arrays.toString(data));
// 输出: [1, 3, 4, 5, 8]

第五部分：常见错误与调试

总结数组操作中的典型错误及解决方案

错误1：空指针异常

// 错误：未初始化直接使用
int[] arr;
arr[0] = 10; // NullPointerException
解决方案：
int[] arr = new int[5]; // 先初始化

错误2：数组越界

int[] arr = {1, 2, 3};
for (int i = 0; i <= arr.length; i++) { // 错误：应该是 <
    System.out.println(arr[i]);
}

错误3：类型不匹配

String[] strs = new String[3];
strs[0] = 123; // 错误：int不能赋值给String

错误4：数组赋值错误

int[] a = {1, 2, 3};
int[] b = a; // 错误：只是引用赋值，不是内容复制
b[0] = 100; // a[0]也会变成100
正确复制数组：
int[] b = Arrays.copyOf(a, a.length);

调试技巧

  • 使用IDE的调试模式查看数组内容
  • System.out.println(Arrays.toString(arr))快速查看数组
  • 循环前打印数组长度确认范围
  • 使用断点检查索引值变化

第六部分：实战练习

通过实际案例巩固数组知识

练习1：计算学生平均分

import java.util.Scanner;

public class AverageCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入学生人数: ");
        int count = scanner.nextInt();
        
        double[] scores = new double[count];
        
        // 输入成绩
        for (int i = 0; i < count; i++) {
            System.out.print("请输入第" + (i + 1) + "个成绩: ");
            scores[i] = scanner.nextDouble();
        }
        
        // 计算平均分
        double sum = 0;
        for (double score : scores) {
            sum += score;
        }
        
        double average = sum / count;
        System.out.printf("平均分为: %.2f", average);
    }
}

练习2：数组反转

public class ArrayReverse {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};
        
        System.out.println("原数组: " + Arrays.toString(original));
        
        // 方法1：使用新数组
        int[] reversed = new int[original.length];
        for (int i = 0; i < original.length; i++) {
            reversed[i] = original[original.length - 1 - i];
        }
        
        // 方法2：原地交换
        for (int i = 0; i < original.length / 2; i++) {
            int temp = original[i];
            original[i] = original[original.length - 1 - i];
            original[original.length - 1 - i] = temp;
        }
        
        System.out.println("反转后: " + Arrays.toString(original));
    }
}

学习总结

  • 数组索引从0开始，最大索引为length-1
  • 数组长度固定，不能动态改变
  • 增强for循环适合只读遍历，需要索引时用传统for
  • Arrays类提供了许多实用的数组操作工具
  • 注意数组越界和空指针异常