Java ArrayList教程 · ZetCode 中文系列教程

# Java `ArrayList`教程原文：http://zetcode.com/articles/javaarraylist/ Java `ArrayList`教程显示了如何使用 Java 中的`ArrayList`集合。 `ArrayList`位于`java.util`包中，是 Java 集合框架的重要集合。 Java 集合框架是用于表示和操作集合的统一架构，使集合可以独立于实现细节进行操作。集合是代表一组对象的对象。 ## Java `ArrayList` `ArrayList`是元素的有序序列。它是动态的并且可调整大小。它提供对元素的随机访问。随机访问意味着我们可以在恒定时间抓取任何元素。添加数据后，`ArrayList`会自动扩展。与简单数组不同，`ArrayList`可以保存多种数据类型的数据。它允许所有元素，包括`null`。 `ArrayList`中的元素通过整数索引访问。索引从零开始。在`ArrayList`的末尾元素的索引以及插入和删除需要固定的时间。 `ArrayList`实例具有容量。容量是用于在列表中存储元素的数组的大小。当元素添加到`ArrayList`时，其容量会自动增长。选择适当的容量可以节省一些时间。 ## Java `ArrayList`添加单个项目可以使用`add()`方法将单个元素添加到`ArrayList`。 `com/zetcode/ListAddItem.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class ListAddItem { public static void main(String[] args) { List<String> langs = new ArrayList<>(); langs.add("Java"); langs.add("Python"); langs.add(1, "C#"); langs.add(0, "Ruby"); for (String lang : langs) { System.out.printf("%s ", lang); } System.out.println(); } } ``` 该示例将元素逐一添加到数组列表中。 ```java List<String> langs = new ArrayList<>(); ``` 创建一个`ArrayList`。在菱形括号（`<>`）中指定的数据类型将元素限制为该数据类型。在我们的例子中，我们有一个字符串列表。 ```java langs.add("Java"); ``` 使用`add()`方法将元素添加到列表的末尾。 ```java langs.add(1, "C#"); ``` 这次，重载的`add()`方法将元素插入指定位置； `"C#"`字符串将位于列表的第二个位置；请记住，`ArrayList`是元素的有序序列。 ```java for (String lang : langs) { System.out.printf("%s ", lang); } ``` 通过`for`循环，我们浏览`ArrayList`列表并打印其元素。 ```java Ruby Java C# Python ``` 这是输出。请注意，元素保持插入顺序。 ## Java 列表从 Java 9 开始，我们有几种工厂方法来创建包含少量元素的列表。创建的列表是不可变的。 `com/zetcode/ListOf.java` ```java package com.zetcode; import java.util.List; public class ListOf { public static void main(String[] args) { var words = List.of("wood", "forest", "falcon", "eagle"); System.out.println(words); var values = List.of(1, 2, 3); System.out.println(values); } } ``` 在示例中，我们创建了两个包含四个和三个元素的列表。 ## Java `ArrayList get()`和`size()` `get()`返回此列表中指定位置的元素，`size()`返回列表的大小。 `com/zetcode/GetAndSizeEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class GetAndSizeEx { public static void main(String[] args) { List<String> colours = new ArrayList<>(); colours.add("blue"); colours.add("orange"); colours.add("red"); colours.add("green"); String col = colours.get(1); System.out.println(col); int size = colours.size(); System.out.printf("The size of the ArrayList is: %d%n", size ); } } ``` 该示例使用了`ArrayList`的`get()`和`size()`方法 ```java String col = colours.get(1); ``` `get()`方法返回第二个元素，即`"orange"`。 ```java int size = colours.size(); ``` `size()`方法确定`colours`列表的大小；我们有四个要素。 ```java orange The size of the ArrayList is: 4 ``` 这是示例的输出。 ## Java `ArrayList`复制可以使用`List.copy()`方法生成列表的副本。 `com/zetcode/ListCopy.java` ```java package com.zetcode; import java.util.List; public class ListCopy { public static void main(String[] args) { var words = List.of("forest", "wood", "eagle", "sky", "cloud"); System.out.println(words); var words2 = List.copyOf(words); System.out.println(words2); } } ``` 该示例使用`List.copy()`创建列表的副本。 ## 原始`ArrayList` `ArrayList`可以包含各种数据类型。这些称为原始列表。 > **注意**：通常不建议使用原始列表。原始列表通常需要强制转换，而且类型安全。 `com/zetcode/DataTypesEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; class Base {} enum Level { EASY, MEDIUM, HARD } public class DataTypesEx { public static void main(String[] args) { Level level = Level.EASY; List da = new ArrayList(); da.add("Java"); da.add(3.5); da.add(55); da.add(new Base()); da.add(level); for (Object el : da) { System.out.println(el); } } } ``` 该示例将五种不同的数据类型添加到数组列表中-字符串，双精度型，整数，对象和枚举。 ```java List da = new ArrayList(); ``` 当我们将多个数据类型添加到列表时，我们省略了尖括号。 ```java Java 3.5 55 com.zetcode.Base@659e0bfd EASY ``` 这是输出。 ## Java `ArrayList`添加多个元素下面的示例使用`addAll()`方法一步将多个元素添加到列表中。 `com/zetcode/AddingMultipleItemsEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class AddingMultipleItemsEx { public static void main(String[] args) { List<String> colours1 = new ArrayList<>(); colours1.add("blue"); colours1.add("red"); colours1.add("green"); List<String> colours2 = new ArrayList<>(); colours2.add("yellow"); colours2.add("pink"); colours2.add("brown"); List<String> colours3 = new ArrayList<>(); colours3.add("white"); colours3.add("orange"); colours3.addAll(colours1); colours3.addAll(2, colours2); for (String col : colours3) { System.out.println(col); } } } ``` 创建两个列表。稍后，使用`addAll()`方法将列表中的元素添加到第三个列表中。 ```java colours3.addAll(colours1); ``` `addAll()`方法将所有元素添加到列表的末尾。 ```java colours3.addAll(2, colours2); ``` 此重载方法添加了从指定位置开始的所有元素。 ```java white orange yellow pink brown blue red green ``` This is the output of the example. ## Java `ArrayList`修改元素下一个示例使用方法来修改`ArrayList`。 `com/zetcode/ModifyingListEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class ModifyingListEx { public static void main(String[] args) { List<String> items = new ArrayList<>(); fillList(items); items.set(3, "watch"); items.add("bowl"); items.remove(0); items.remove("pen"); for (Object el : items) { System.out.println(el); } items.clear(); if (items.isEmpty()) { System.out.println("The list is empty"); } else { System.out.println("The list is not empty"); } } public static void fillList(List<String> list) { list.add("coin"); list.add("pen"); list.add("pencil"); list.add("clock"); list.add("book"); list.add("spectacles"); list.add("glass"); } } ``` 使用`set()`，`add()`，`remove()`和`clear()`方法创建和修改`ArrayList`。 ```java items.set(3, "watch"); ``` `set()`方法将第四个元素替换为`"watch"`项。 ```java items.add("bowl"); ``` `add()`方法在列表的末尾添加一个新元素。 ```java items.remove(0); ``` `remove()`方法删除索引为 0 的第一个元素。 ```java items.remove("pen"); ``` 重载的`remove()`方法删除`"pen"`项的第一次出现。 ```java items.clear(); ``` `clear()`方法从列表中删除所有元素。 ```java if (items.isEmpty()) { ``` `isEmpty()`方法确定列表是否为空。 ```java pencil watch book spectacles glass bowl The list is empty ``` This is the output of the example. ## Java `ArrayList removeIf` `removeIf()`方法删除满足给定谓词的集合中的所有元素。 `com/zetcode/RemoveIfEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class RemoveIfEx { public static void main(String[] args) { List<Integer> values = new ArrayList<>(); values.add(5); values.add(-3); values.add(2); values.add(8); values.add(-2); values.add(6); values.removeIf(val -> val < 0); System.out.println(values); } } ``` 在我们的示例中，我们有一个`ArrayList`整数。我们使用`removeIf`方法删除所有负值。 ```java values.removeIf(val -> val < 0); ``` 所有负数将从数组列表中删除。 ```java [5, 2, 8, 6] ``` 这是输出。 ## Java `ArrayList removeAll` `removeAll()`方法从该列表中删除指定集合中包含的所有其元素。请注意，所有元素都已通过`clear()`删除。 `com/zetcode/RemoveAll.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class RemoveAll { public static void main(String[] args) { List<String> letters = new ArrayList<>(); letters.add("a"); letters.add("b"); letters.add("c"); letters.add("a"); letters.add("d"); System.out.println(letters); letters.removeAll(Collections.singleton("a")); System.out.println(letters); } } ``` 在示例中，我们从列表中删除了所有`"a"`字母。 ## Java `ArrayList replaceAll` `replaceAll()`方法用将运算符应用于该元素的结果替换列表的每个元素。 `com/zetcode/ReplaceAllEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; import java.util.function.UnaryOperator; public class ReplaceAllEx { public static void main(String[] args) { List<String> items = new ArrayList<>(); items.add("coin"); items.add("pen"); items.add("cup"); items.add("notebook"); items.add("class"); UnaryOperator<String> uo = (x) -> x.toUpperCase(); items.replaceAll(uo); System.out.println(items); } } ``` 该示例在每个列表元素上应用了一个运算符。元素的字母转换为大写。 ```java UnaryOperator<String> uo = (x) -> x.toUpperCase(); ``` 创建将字母转换为大写的`UnaryOperator`。 ```java items.replaceAll(uo); ``` 使用`replaceAll()`方法将运算符应用于列表元素。 ```java [COIN, PEN, CUP, NOTEBOOK, CLASS] ``` 这是输出。第二个示例使用`replaceAll()`方法将字符串项目大写。 `com/zetcode/ReplaceAllEx2.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; import java.util.function.UnaryOperator; class MyOperator<T> implements UnaryOperator<String> { @Override public String apply(String var) { if (var == null || var.length() == 0) { return var; } return var.substring(0, 1).toUpperCase() + var.substring(1); } } public class ReplaceAllEx2 { public static void main(String[] args) { List<String> items = new ArrayList<>(); items.add("coin"); items.add("pen"); items.add("cup"); items.add("notebook"); items.add("glass"); items.replaceAll(new MyOperator<>()); System.out.println(items); } } ``` 我们有一个字符串项目列表。这些项目在`replaceAll()`方法的帮助下大写。 ```java class MyOperator<T> implements UnaryOperator<String> { ``` 创建自定义`UnaryOperator`。 ```java @Override public String apply(String var) { if (var == null || var.length() == 0) { return var; } return var.substring(0, 1).toUpperCase() + var.substring(1); } ``` 在`UnaryOperator`的`apply()`方法中，我们使用第一个大写字母还原字符串。 ```java items.replaceAll(new MyOperator<>()); ``` 将运算符应用于列表项。 ```java [Coin, Pen, Cup, Notebook, Glass] ``` This is the output of the example. ## Java `ArrayList.contains()` 如果列表包含指定的元素，则`contains()`方法返回`true`。 `com/zetcode/ContainsEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class ContainsEx { public static void main(String[] args) { List<String> items = new ArrayList<>(); items.add("coin"); items.add("pen"); items.add("cup"); items.add("notebook"); items.add("class"); String item = "pen"; if (items.contains(item)) { System.out.printf("There is a %s in the list%n", item); } } } ``` 该示例检查指定的项目是否在列表中。 ```java if (items.contains(item)) { System.out.printf("There is a %s in the list%n", item); } ``` 如果该项目在列表中，则会打印该消息。 ```java There is a pen in the list ``` 这是输出。 ## 获取`ArrayList`中元素的索引 `ArrayList`中的每个元素都有其自己的索引号。 `indexOf()`返回指定元素首次出现的索引，如果列表不包含该元素，则返回 -1。 `lasindexOf()`返回指定元素最后一次出现的索引；如果列表中不包含该元素，则返回 -1。 `com/zetcode/GetIndexEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class GetIndexEx { public static void main(String[] args) { List<String> colours = new ArrayList<>(); colours.add(0, "blue"); colours.add(1, "orange"); colours.add(2, "red"); colours.add(3, "green"); colours.add(4, "orange"); int idx1 = colours.indexOf("orange"); System.out.println(idx1); int idx2 = colours.lastIndexOf("orange"); System.out.println(idx2); } } ``` 该示例打印`"orange"`元素的第一个和最后一个索引。 ```java 1 4 ``` 这是示例输出。 # Java 列表的列表 We can add other lists into a list. `com/zetcode/ListOfLists.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class ListOfLists { public static void main(String[] args) { List<Integer> l1 = new ArrayList<>(); l1.add(1); l1.add(2); l1.add(3); List<Integer> l2 = new ArrayList<>(); l2.add(4); l2.add(5); l2.add(6); List<Integer> l3 = new ArrayList<>(); l3.add(7); l3.add(8); l3.add(9); List<List<Integer>> nums = new ArrayList<>(); nums.add(l1); nums.add(l2); nums.add(l3); System.out.println(nums); for (List<Integer> list : nums) { for (Integer n : list) { System.out.printf("%d ", n); } System.out.println(); } } } ``` 该示例创建三个整数列表。以后，这些列表将添加到另一个第四列表中。 ```java List<Integer> l1 = new ArrayList<>(); l1.add(1); l1.add(2); l1.add(3); ``` 将创建一个整数列表。 ```java List<List> nums = new ArrayList<>(); nums.add(l1); nums.add(l2); nums.add(l3); ``` 创建列表列表。 ```java for (List<Integer> list : nums) { for (Integer n : list) { System.out.printf("%d ", n); } System.out.println(); } ``` 我们使用两个`for`循环遍历所有元素。 ```java [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 1 2 3 4 5 6 7 8 9 ``` 这是程序的输出。 ## Java `ArrayList`子列表 `subList()`方法返回指定的`fromIndex`（包括）和`toIndex`（不包括）之间的列表部分的视图。子列表中的更改将反映在原始列表中。 `com/zetcode/SubListEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class SubListEx { public static void main(String[] args) { List<String> items = new ArrayList<>(); items.add("coin"); items.add("pen"); items.add("cup"); items.add("notebook"); items.add("glass"); items.add("chair"); items.add("ball"); items.add("bowl"); List<String> items2 = items.subList(2, 5); System.out.println(items2); items2.set(0, "bottle"); System.out.println(items2); System.out.println(items); } } ``` 该示例从项目列表创建子列表。 ```java List<String> items2 = items.subList(2, 5); ``` 使用`subList()`方法创建一个子列表。它包含索引为 2、3 和 4 的项目。 ```java items2.set(0, "bottle"); ``` 我们替换子列表的第一项；修改也反映在原始列表中。 ```java [cup, notebook, glass] [bottle, notebook, glass] [coin, pen, bottle, notebook, glass, chair, ball, bowl] ``` This is the output of the example. ## Java `ArrayList`遍历在下面的示例中，我们展示了遍历`ArrayList`的五种方法。 `com/zetcode/TraversingArrayListEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; public class TraversingArrayListEx { public static void main(String[] args) { List<Integer> nums = new ArrayList<>(); nums.add(2); nums.add(6); nums.add(7); nums.add(3); nums.add(1); nums.add(8); for (int i = 0; i < nums.size(); i++) { System.out.printf("%d ", nums.get(i)); } System.out.println(); for (int num : nums) { System.out.printf("%d ", num); } System.out.println(); int j = 0; while (j < nums.size()) { System.out.printf("%d ", nums.get(j)); j++; } System.out.println(); ListIterator<Integer> it = nums.listIterator(); while(it.hasNext()) { System.out.printf("%d ", it.next()); } System.out.println(); nums.forEach(e -> System.out.printf("%d ", e)); System.out.println(); } } ``` 在示例中，我们遍历具有`for`循环，`while`循环，迭代器和`forEach()`构造的整数数组列表。 ```java List<Integer> nums = new ArrayList<>(); nums.add(2); nums.add(6); nums.add(7); nums.add(3); nums.add(1); nums.add(8); ``` 我们创建了一个`ArrayList`整数。 ```java for (int i = 0; i < nums.size(); i++) { System.out.printf("%d ", nums.get(i)); } ``` 在这里，我们使用经典的`for`循环遍历列表。 ```java for (int num : nums) { System.out.printf("%d ", num); } ``` 第二种方法使用 Java 5 中引入的增强`for`循环。 ```java int j = 0; while (j < nums.size()) { System.out.printf("%d ", nums.get(j)); j++; } ``` 第三种方式使用`while`循环。 ```java ListIterator<Integer> it = nums.listIterator(); while(it.hasNext()) { System.out.printf("%d ", it.next()); } ``` 这里，`ListIterator`用于遍历列表。 ```java nums.forEach(e -> System.out.printf("%d ", e)); ``` 最后，我们使用 Java8 中引入的`forEach()`方法。 ```java 2 6 7 3 1 8 2 6 7 3 1 8 2 6 7 3 1 8 2 6 7 3 1 8 2 6 7 3 1 8 ``` 该示例使用各种技术将列表的元素打印到控制台。 ## Java `ArrayList`排序对`ArrayList`进行分类有不同的浪费。 ### 使用其`sort`方法对`ArrayList`进行排序 `ArrayList`的`sort()`方法根据由指定比较器引起的顺序对列表进行排序。 `com/zetcode/ArrayListSortingEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.Comparator; import java.util.List; class Person { private int age; private String name; public Person(int age, String name) { this.age = age; this.name = name; } public int getAge() { return age; } @Override public String toString() { return "Age: " + age + " Name: " + name; } } public class ArrayListSortingEx { public static void main(String[] args) { List<Person> persons = createList(); persons.sort(Comparator.comparing(Person::getAge).reversed()); System.out.println(persons); } private static List<Person> createList() { List<Person> persons = new ArrayList<>(); persons.add(new Person(17, "Jane")); persons.add(new Person(32, "Peter")); persons.add(new Person(47, "Patrick")); persons.add(new Person(22, "Mary")); persons.add(new Person(39, "Robert")); persons.add(new Person(54, "Greg")); return persons; } } ``` 我们有一个自定义`Person`类的`ArrayList`。我们按照年龄的相反顺序对其进行排序。 ```java persons.sort(Comparator.comparing(Person::getAge).reversed()); ``` 此行按年龄（从最大到最小）对人员进行分类。 ```java [Age: 54 Name: Greg, Age: 47 Name: Patrick, Age: 39 Name: Robert, Age: 32 Name: Peter, Age: 22 Name: Mary, Age: 17 Name: Jane] ``` 这是输出。 ### 使用 Java8 流对`ArrayList`进行排序在第二个示例中，我们使用 Java 流对`ArrayList`进行排序。流 API 是一种更强大的排序方式。 `com/zetcode/ArrayListSortingEx2.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; class Country { private String name; private int population; public Country(String name, int population) { this.name = name; this.population = population; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getPopulation() { return population; } public void setPopulation(int population) { this.population = population; } @Override public String toString() { return "Country{" + "name=" + name + ", population=" + population + '}'; } } public class ArrayListSortingEx2 { public static void main(String[] args) { List<Country> countries = createList(); List<Country> sorted_countries = countries.stream() .sorted((e1, e2) -> Integer.compare(e1.getPopulation(), e2.getPopulation())).collect(Collectors.toList()); System.out.println(sorted_countries); } private static List<Country> createList() { List<Country> countries = new ArrayList<>(); countries.add(new Country("Slovakia", 5424000)); countries.add(new Country("Hungary", 9845000)); countries.add(new Country("Poland", 38485000)); countries.add(new Country("Germany", 81084000)); countries.add(new Country("Latvia", 1978000)); return countries; } } ``` 在此示例中，我们有一个国家/地区列表。每个国家都有名字和人口。这些国家是按人口排序的。 ```java List<Country> sorted_countries = countries.stream() .sorted((e1, e2) -> Integer.compare(e1.getPopulation(), e2.getPopulation())).collect(Collectors.toList()); ``` 使用`stream()`方法，我们从列表创建流。 `sorted()`方法根据提供的比较器对元素进行排序。使用`Integer.compare()`，我们比较了国家/地区的人口。使用`collect()`，我们将信息流转换为国家列表。 ```java [Country{name=Latvia, population=1978000}, Country{name=Slovakia, population=5424000}, Country{name=Hungary, population=9845000}, Country{name=Poland, population=38485000}, Country{name=Germany, population=81084000}] ``` 这是输出。这些国家按人口升序排序。 ## 使用`ArrayList`和简单的 Java 数组下面的示例使用带有简单 Java 数组的`ArrayList`。 `com/zetcode/ListToArray.java` ```java package com.zetcode; import java.util.Arrays; import java.util.List; public class ListToArray { public static void main(String[] args) { List<String> planets = Arrays.asList("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"); System.out.println(planets); String[] planets2 = planets.toArray(new String[0]); System.out.println(Arrays.toString(planets2)); } } ``` `ArrayList`转换为数组，反之亦然。 ```java List<String> planets = Arrays.asList("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"); ``` 使用`Arrays.asList()`方法，我们创建了一个由指定数组支持的固定大小的列表。 ```java String[] planets2 = planets.toArray(new String[0]); ``` `ArrayList`的`toArray()`用于将列表转换为数组。 ## 流到列表的转换可以使用收集器将 Java 流转换为列表。 `com/zetcode/ToList.java` ```java package com.zetcode; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; public class ToList { public static void main(String[] args) { var words = Stream.of("forest", "eagle", "river", "cloud", "sky"); List<String> words2 = words.collect(Collectors.toList()); System.out.println(words2.getClass()); } } ``` 我们有一串串的字符串。我们使用`Collectors.toList()`将流转换为列表。 ```java class java.util.ArrayList ``` 这是输出。在本教程中，我们使用了 Java `ArrayList`容器。您可能也对以下相关教程感兴趣： [Java `HashMap`教程](/java/hashmap)， [Java `HashSet`教程](/java/hashset)， [Java 教程](/lang/java/)， [Google Guava 简介](/articles/guava/) ，[在 Java 中过滤列表](/java/filterlist/)，或[在 Java 中读取网页](/articles/javareadwebpage/)。列出所有 [Java 教程](/all/#java)。