8.3 数组的访问与遍历

数组的访问

数组的访问是指通过索引来获取或修改数组中的元素。在 Java 中，数组的索引从 0 开始，到数组长度减 1 结束。

访问数组元素

语法：

数组名[索引]

示例：

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

// 访问数组元素
int firstElement = numbers[0]; // 获取第一个元素，值为 10
int lastElement = numbers[4];  // 获取最后一个元素，值为 50

// 修改数组元素
numbers[0] = 100; // 将第一个元素修改为 100
System.out.println(numbers[0]); // 输出 100

数组索引的范围

数组的索引范围是 0 到 数组长度 - 1。如果使用超出这个范围的索引，会导致 ArrayIndexOutOfBoundsException 异常。

int[] numbers = {1, 2, 3};
System.out.println(numbers[3]); // 错误：ArrayIndexOutOfBoundsException

数组的遍历

数组的遍历是指依次访问数组中的每个元素。在 Java 中，有多种方式可以遍历数组：

1. 使用 for 循环遍历

public class ForLoopTraversalExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        
        // 使用 for 循环遍历数组
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }
    }
}

2. 使用增强型 for 循环（for-each）遍历

增强型 for 循环（也称为 for-each 循环）是 Java 5 引入的一种简化的循环方式，专门用于遍历数组和集合。

public class ForEachTraversalExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        
        // 使用增强型 for 循环遍历数组
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

3. 使用 while 循环遍历

public class WhileLoopTraversalExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int i = 0;
        
        // 使用 while 循环遍历数组
        while (i < numbers.length) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
            i++;
        }
    }
}

4. 使用 do…while 循环遍历

public class DoWhileLoopTraversalExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int i = 0;
        
        // 使用 do…while 循环遍历数组
        do {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
            i++;
        } while (i < numbers.length);
    }
}

数组遍历的应用

1. 计算数组元素的和

public class ArraySumExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int sum = 0;
        
        // 计算数组元素的和
        for (int number : numbers) {
            sum += number;
        }
        
        System.out.println("Sum: " + sum);
    }
}

2. 查找数组中的最大值

public class FindMaxExample {
    public static void main(String[] args) {
        int[] numbers = {10, 30, 50, 20, 40};
        int max = numbers[0];
        
        // 查找数组中的最大值
        for (int number : numbers) {
            if (number > max) {
                max = number;
            }
        }
        
        System.out.println("Maximum value: " + max);
    }
}

3. 查找数组中的最小值

public class FindMinExample {
    public static void main(String[] args) {
        int[] numbers = {10, 30, 50, 20, 40};
        int min = numbers[0];
        
        // 查找数组中的最小值
        for (int number : numbers) {
            if (number < min) {
                min = number;
            }
        }
        
        System.out.println("Minimum value: " + min);
    }
}

4. 统计数组中元素的出现次数

public class CountOccurrencesExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 2, 1, 2, 3, 4, 5, 4, 3, 2, 1};
        int target = 2;
        int count = 0;
        
        // 统计 target 在数组中出现的次数
        for (int number : numbers) {
            if (number == target) {
                count++;
            }
        }
        
        System.out.println("Number of occurrences of " + target + ": " + count);
    }
}

示例：数组访问与遍历的使用

示例 1：遍历数组并修改元素

public class ModifyArrayExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        System.out.println("Original array:");
        for (int number : numbers) {
            System.out.print(number + " ");
        }
        System.out.println();
        
        // 将数组中的每个元素乘以 2
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] *= 2;
        }
        
        System.out.println("Modified array:");
        for (int number : numbers) {
            System.out.print(number + " ");
        }
        System.out.println();
    }
}

示例 2：遍历字符串数组

public class StringArrayTraversalExample {
    public static void main(String[] args) {
        String[] names = {"Alice", "Bob", "Charlie", "David", "Eve"};
        
        System.out.println("Names:");
        for (int i = 0; i < names.length; i++) {
            System.out.println((i + 1) + ". " + names[i]);
        }
        
        // 使用增强型 for 循环
        System.out.println("\nNames (using for-each):");
        int index = 1;
        for (String name : names) {
            System.out.println(index + ". " + name);
            index++;
        }
    }
}

示例 3：遍历二维数组

public class TwoDimensionalArrayTraversalExample {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        System.out.println("Matrix:");
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

常见问题

1. 数组索引越界

症状：运行时错误：ArrayIndexOutOfBoundsException

解决方案：确保数组索引在有效范围内（0 到 length-1）

2. 空指针异常

症状：运行时错误：NullPointerException

解决方案：确保数组已经初始化，不为 null

3. 增强型 for 循环的局限性

症状：无法在增强型 for 循环中修改数组元素的索引

解决方案：如果需要修改数组元素的索引，使用普通的 for 循环

总结

数组的访问和遍历是 Java 中使用数组的基本操作。通过索引可以访问和修改数组中的元素，通过循环可以遍历数组中的所有元素。

在使用数组时，需要注意：

• 数组索引的范围是 0 到 length-1，避免数组索引越界
• 确保数组已经初始化，避免空指针异常
• 根据需要选择合适的遍历方式：
  • 普通 for 循环：需要索引时使用
  • 增强型 for 循环：不需要索引时使用，代码更简洁
  • while 或 do…while 循环：需要更灵活的循环控制时使用

通过合理使用数组的访问和遍历，可以有效地处理数组中的数据，实现各种复杂的功能。