Java 数组与 ArrayList

介绍

在本实验中，我们将深入探讨 Java 中的两种基本数据结构：数组（Arrays）和数组列表（ArrayLists）。这些结构允许我们存储和操作数据集合，这对于许多编程任务至关重要。我们将从基本的数组开始，然后转向更灵活的 ArrayList。通过本实验的学习，你将能够在 Java 中创建、操作和使用数组和 ArrayLists。

我们将涵盖以下内容：

1. 创建和使用数组
2. 访问和修改数组元素
3. ArrayList 简介
4. 在 ArrayList 中添加、删除和访问元素
5. 数组和 ArrayList 之间的转换

让我们开始组织我们的数据吧！

Skills Graph

创建和使用数组

数组是 Java 中的一种基本数据结构，它允许你存储多个相同类型的元素。你可以将数组想象成一排盒子，每个盒子可以存放一个特定类型的元素。

1. 首先，打开项目目录中的 ArrayDemo.java 文件。

   public class ArrayDemo {
       public static void main(String[] args) {
           // 我们将在这里添加代码
       }
   }

   这是 Java 程序的基本结构。main 方法是程序开始执行的地方。

2. 接下来，声明并初始化一个整数数组。在 main 方法中添加以下代码：

   int[] numbers = {1, 2, 3, 4, 5};

   这行代码创建了一个名为 numbers 的整数数组，并用值 1、2、3、4 和 5 初始化它。方括号 [] 告诉 Java numbers 是一个数组。

3. 打印数组中的元素。在数组声明后添加以下代码：

   System.out.println("数组的元素为：");
   for (int i = 0; i < numbers.length; i++) {
       System.out.println("索引 " + i + " 处的元素: " + numbers[i]);
   }

   这段代码使用 for 循环遍历数组。numbers.length 获取数组的大小，numbers[i] 访问索引为 i 的元素。

   

4. 保存文件，然后编译并运行程序：

   javac ~/project/ArrayDemo.java
   java -cp ~/project ArrayDemo

   你应该会看到类似以下的输出：

   数组的元素为：
   索引 0 处的元素: 1
   索引 1 处的元素: 2
   索引 2 处的元素: 3
   索引 3 处的元素: 4
   索引 4 处的元素: 5

5. 现在，计算数组中所有元素的总和。在上一个循环后添加以下代码：

   int sum = 0;
   for (int number : numbers) {
       sum += number;
   }
   System.out.println("元素的总和为: " + sum);

   这段代码使用增强型 for 循环（也称为 for-each 循环）遍历数组。当你不需要索引时，这是一种更简单的遍历方式。

6. 最后，找到数组中的最大值。添加以下代码：

   int max = numbers[0];
   for (int i = 1; i < numbers.length; i++) {
       if (numbers[i] > max) {
           max = numbers[i];
       }
   }
   System.out.println("数组中的最大值是: " + max);

   这段代码首先假设第一个元素是最大值，然后依次比较后续元素与当前最大值，如果找到更大的值则更新最大值。

7. 保存、编译并再次运行程序。你应该会看到额外的输出：

   元素的总和为: 15
   数组中的最大值是: 5

   

8. Java 中的数组大小是固定的，但我们可以修改其元素。让我们修改一个元素并打印修改后的数组。在 main 方法的末尾添加以下代码：

   numbers[2] = 10;
   System.out.println("\n修改第三个元素后：");
   for (int number : numbers) {
       System.out.print(number + " ");
   }
   System.out.println();

   这段代码将第三个元素（索引 2）的值改为 10，然后打印修改后的数组。

9. 保存、编译并再次运行程序。你应该会看到额外的输出：

   修改第三个元素后：
   1 2 10 4 5

恭喜！你现在已经创建了一个数组，访问了它的元素，对其值进行了计算，并修改了一个元素。记住，Java 中的数组大小是固定的，这意味着一旦创建了数组，你就无法更改其长度。但是，你可以更改其元素的值。

ArrayList 简介

现在我们已经学习了数组，接下来让我们介绍 ArrayList。ArrayList 是 Java 集合框架的一部分，它提供了一种更灵活的方式来处理对象列表。与数组不同，ArrayList 可以动态地增长或缩小。

1. 打开项目目录中的 ArrayListDemo.java 文件。

   import java.util.ArrayList;
   
   public class ArrayListDemo {
       public static void main(String[] args) {
           // 我们将在这里添加代码
       }
   }

   注意顶部的 import 语句。这告诉 Java 我们希望在程序中使用 ArrayList 类。

2. 现在，让我们创建一个存储字符串的 ArrayList。在 main 方法中添加以下代码：

   ArrayList<String> fruits = new ArrayList<>();

   这创建了一个可以存储 String 对象的空 ArrayList。<String> 部分称为“泛型”，它指定了 ArrayList 将包含的元素类型。

3. 让我们向 ArrayList 中添加一些元素。添加以下代码：

   fruits.add("Apple");
   fruits.add("Banana");
   fruits.add("Cherry");

   add() 方法将元素追加到列表的末尾。

4. 现在，打印我们的 ArrayList。添加以下代码：

   System.out.println("列表中的水果：");
   for (String fruit : fruits) {
       System.out.println(fruit);
   }

   这段代码使用增强型 for 循环遍历 ArrayList，类似于我们之前对数组的操作。

   提示：你可以随时编译并运行程序以查看输出。或者，你可以继续添加更多代码，最后一次性运行。

5. ArrayList 有许多有用的方法。让我们尝试几个。添加以下代码：

   System.out.println("\n水果的数量: " + fruits.size());
   System.out.println("第二个水果是: " + fruits.get(1));

   size() 返回 ArrayList 中元素的数量，get(index) 获取指定索引处的元素。

6. 我们还可以使用 set() 方法替换 ArrayList 中的元素。添加以下代码：

   // 替换前: [Apple, Banana, Cherry]
   fruits.set(1, "Blueberry");    // 将 "Banana" 替换为 "Blueberry"
   System.out.println("\n替换第二个水果后：");
   System.out.println(fruits);     // [Apple, Blueberry, Cherry]

   set(index, element) 将指定索引处的元素替换为新元素。ArrayList 的大小保持不变。

7. 与数组不同，ArrayList 允许我们使用 add(index, element) 方法在任何位置插入元素。这与我们之前看到的 set() 不同。让我们看看 add() 的工作原理：

   // 插入前: [Apple, Blueberry, Cherry]
   fruits.add(1, "Blackberry");
   System.out.println("\n在索引 1 处插入 Blackberry 后：");
   System.out.println(fruits);
   // 插入后: [Apple, Blackberry, Blueberry, Cherry]

   让我们理解发生了什么：

   • add(1, "Blackberry") 在索引 1 处插入 "Blackberry"
   • 索引 1 及之后的现有元素（Blueberry, Cherry）会自动向右移动一个位置
   • ArrayList 的大小增加 1
   • 这与 set() 不同，后者会替换现有元素而不移动或改变大小

   为了帮助理解区别：

   // 使用 add(index, element) - 插入并移动元素
   fruits.add(1, "Blackberry");    // [Apple, Blackberry, Blueberry, Cherry]
   
   // 使用 set(index, element) - 替换而不移动元素
   fruits.set(1, "Blackberry");    // [Apple, Blackberry, Cherry]

8. 我们还可以从 ArrayList 中移除元素。添加以下代码：

   fruits.remove("Cherry");
   System.out.println("\n移除 Cherry 后：");
   System.out.println(fruits);

   这会移除 ArrayList 中第一次出现的 "Cherry"。当一个元素被移除时，后续元素会向左移动以填补空缺。

9. 最后，让我们检查 ArrayList 中是否包含某些元素：

   System.out.println("\n列表中是否包含 Apple? " + fruits.contains("Apple"));
   System.out.println("列表中是否包含 Cherry? " + fruits.contains("Cherry"));

   contains() 方法检查 ArrayList 是否包含特定元素，并返回一个布尔值。

10. 保存文件，然后编译并运行程序：

    javac ~/project/ArrayListDemo.java
    java -cp ~/project ArrayListDemo

    你应该会看到类似以下的输出：

    列表中的水果：
    Apple
    Banana
    Cherry
    
    水果的数量: 3
    第二个水果是: Banana
    
    替换第二个水果后：
    [Apple, Blueberry, Cherry]
    
    在索引 1 处插入 Blackberry 后：
    [Apple, Blackberry, Blueberry, Cherry]
    
    移除 Cherry 后：
    [Apple, Blackberry, Blueberry]
    
    列表中是否包含 Apple? true
    列表中是否包含 Cherry? false

恭喜！你现在已经创建了一个 ArrayList，添加和移除了元素，通过索引访问元素，并使用了各种 ArrayList 方法。你已经了解了 add() 和 set() 等操作的重要区别，前者插入并移动元素，后者替换元素。ArrayList 比数组更灵活，因为它们可以根据需要增长和缩小。这使得它们在你不确定要处理多少元素时非常有用。

数组和 ArrayList 之间的转换

有时你可能需要在数组和 ArrayList 之间进行转换。Java 提供了方便的方法来实现这一点。让我们探索如何将数组转换为 ArrayList，以及如何将 ArrayList 转换为数组。

1. 打开项目目录中的 ConversionDemo.java 文件。

   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.List;
   
   public class ConversionDemo {
       public static void main(String[] args) {
           // 我们将在这里添加代码
       }
   }

   注意顶部的 import 语句。我们导入了转换所需的类。

2. 让我们从将数组转换为 ArrayList 开始。在 main 方法中添加以下代码：

   String[] colorArray = {"Red", "Green", "Blue"};
   List<String> colorList = Arrays.asList(colorArray);
   
   System.out.println("数组转换为 ArrayList：");
   System.out.println(colorList);

   Arrays.asList() 将数组转换为 List。注意，这会创建一个由原始数组支持的固定大小的列表。

3. 让我们修改 ArrayList 并观察原始数组的变化。添加以下代码：

   colorList.set(1, "Yellow");
   
   System.out.println("\n修改 ArrayList 后：");
   System.out.println(colorList);
   System.out.println("修改 ArrayList 后的原始数组：");
   System.out.println(Arrays.toString(colorArray));

   Arrays.toString() 是一个方便的方法，用于打印数组。

4. 现在，让我们将 ArrayList 转换为数组。添加以下代码：

   ArrayList<Integer> numberList = new ArrayList<>();
   numberList.add(1);
   numberList.add(2);
   numberList.add(3);
   
   Integer[] numberArray = numberList.toArray(new Integer[0]);
   
   System.out.println("\nArrayList 转换为数组：");
   System.out.println(Arrays.toString(numberArray));

   我们使用 ArrayList 的 toArray() 方法将其转换为数组。我们传递 new Integer[0] 作为参数，这为要创建的数组的类型和大小提供了提示。

5. 最后，让我们修改数组并观察是否会影响 ArrayList。添加以下代码：

   numberArray[0] = 100;
   System.out.println("\n修改数组后：");
   System.out.println("数组: " + Arrays.toString(numberArray));
   System.out.println("ArrayList: " + numberList);

6. 保存文件，然后编译并运行程序：

   javac ~/project/ConversionDemo.java
   java -cp ~/project ConversionDemo

   你应该会看到类似以下的输出：

   数组转换为 ArrayList：
   [Red, Green, Blue]
   
   修改 ArrayList 后：
   [Red, Yellow, Blue]
   修改 ArrayList 后的原始数组：
   [Red, Yellow, Blue]
   
   ArrayList 转换为数组：
   [1, 2, 3]
   
   修改数组后：
   数组: [100, 2, 3]
   ArrayList: [1, 2, 3]

这个演示展示了数组和 ArrayList 如何相互转换。需要注意的是它们的行为差异：

• 当你使用 Arrays.asList() 将数组转换为 List 时，生成的 List 由原始数组支持。这意味着对 List 的更改将反映在数组中，反之亦然。
• 当你使用 toArray() 将 ArrayList 转换为数组时，你会创建一个独立于 ArrayList 的新数组。对这个新数组的更改不会影响原始 ArrayList。

理解这些转换及其行为在 Java 中处理不同集合类型时至关重要，尤其是在与可能偏好某种类型的 API 或库交互时。

总结

在本实验中，我们探索了 Java 中的两种基本数据结构：数组（Arrays）和数组列表（ArrayLists）。让我们回顾一下我们所学到的内容：

1. 数组：

   • 我们使用语法 int[] numbers = {1, 2, 3, 4, 5}; 创建并初始化了数组
   • 我们学习了如何使用索引符号访问数组元素，例如 numbers[0]
   • 我们使用传统的 for 循环和增强型 for 循环遍历数组
   • 我们对数组元素进行了计算，例如求和和查找最大值
   • 我们了解到数组的大小是固定的，但可以修改其元素

2. ArrayList：

   • 我们使用 ArrayList<String> fruits = new ArrayList<>(); 创建了 ArrayList
   • 我们学习了如何使用 add() 添加元素，使用 remove() 移除元素，以及使用 get() 访问元素
   • 我们使用了 size()、set() 和 contains() 等方法来操作 ArrayList
   • 我们了解到 ArrayList 可以动态增长和缩小，比数组更灵活

3. 数组和 ArrayList 之间的转换：

   • 我们使用 Arrays.asList() 将数组转换为 ArrayList
   • 我们使用 toArray() 方法将 ArrayList 转换为数组
   • 我们观察了修改转换后的集合时的不同行为

数组和 ArrayList 是 Java 编程中的基本工具。数组适用于处理固定数量的元素，并且在内存使用方面可能更高效。而 ArrayList 则提供了更多的灵活性以及丰富的集合操作方法。

随着你继续学习 Java，你会发现自己在编程中频繁使用数组和 ArrayList。选择使用哪种数据结构通常取决于你的具体需求——如果你知道要处理的元素的确切数量，数组可能是更好的选择。如果你需要一个可以动态增长或缩小的集合，或者需要 ArrayList 提供的额外方法，那么 ArrayList 会是更合适的选择。