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

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();
    }
}

该示例将元素逐一添加到数组列表中。

List<String> langs = new ArrayList<>();

创建一个ArrayList。在菱形括号（< >）中指定的数据类型将元素限制为该数据类型。在我们的例子中，我们有一个字符串列表。

langs.add("Java");

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

langs.add(1, "C#");

这次，重载的add()方法将元素插入指定位置； “ C# ”字符串将位于列表的第二个位置；请记住，ArrayList是元素的有序序列。

for (String lang : langs) {

    System.out.printf("%s ", lang);
}

通过for循环，我们浏览ArrayList列表并打印其元素。

Ruby Java C# Python

这是输出。请注意，元素保持插入顺序。

Java 列表

从 Java 9 开始，我们有几种工厂方法来创建包含少量元素的列表。创建的列表是不可变的。

com/zetcode/ListOf.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

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()方法

String col = colours.get(1);

get()方法返回第二个元素，即“橙色”。

int size = colours.size();

size()方法确定colours列表的大小；我们有四个要素。

orange
The size of the ArrayList is: 4

这是示例的输出。

Java `ArrayList`复制

可以使用List.copy()方法生成列表的副本。

com/zetcode/ListCopy.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可以包含各种数据类型。这些称为原始列表。

Note: It is generally not recommended to use raw lists.

原始列表通常需要强制转换，而且类型安全。

com/zetcode/DataTypesEx.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);
        }
    }

}

该示例将五种不同的数据类型添加到数组列表中-字符串，双精度型，整数，对象和枚举。

List da = new ArrayList();

当我们将多个数据类型添加到列表时，我们省略了尖括号。

Java
3.5
55
com.zetcode.Base@659e0bfd
EASY

这是输出。

Java `ArrayList`添加多个元素

下面的示例使用addAll()方法一步将多个元素添加到列表中。

com/zetcode/AddingMultipleItemsEx.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()方法将列表中的元素添加到第三个列表中。

colours3.addAll(colours1);

addAll()方法将所有元素添加到列表的末尾。

colours3.addAll(2, colours2);

此重载方法添加了从指定位置开始的所有元素。

white
orange
yellow
pink
brown
blue
red
green

This is the output of the example.

Java `ArrayList`修改元素

下一个示例使用方法来修改ArrayList。

com/zetcode/ModifyingListEx.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。

items.set(3, "watch");

set()方法将第四个元素替换为“ watch”项。

items.add("bowl");

add()方法在列表的末尾添加一个新元素。

items.remove(0);

remove()方法删除索引为 0 的第一个元素。

items.remove("pen");

重载的remove()方法删除“ pen”项的第一次出现。

items.clear();

clear()方法从列表中删除所有元素。

if (items.isEmpty()) {

isEmpty()方法确定列表是否为空。

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

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方法删除所有负值。

values.removeIf(val -> val < 0);

所有负数将从数组列表中删除。

[5, 2, 8, 6]

This is the output.

Java `ArrayList removeAll`

removeAll()方法从该列表中删除指定集合中包含的所有其元素。请注意，所有元素都已通过clear()删除。

com/zetcode/RemoveAll.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

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);
    }
}

该示例在每个列表元素上应用了一个运算符。元素的字母转换为大写。

UnaryOperator<String> uo = (x) -> x.toUpperCase();

创建将字母转换为大写的UnaryOperator。

items.replaceAll(uo);

使用replaceAll()方法将运算符应用于列表元素。

[COIN, PEN, CUP, NOTEBOOK, CLASS]

This is the output.

第二个示例使用replaceAll()方法将字符串项目大写。

com/zetcode/ReplaceAllEx2.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()方法的帮助下大写。

class MyOperator<T> implements UnaryOperator<String> {

创建自定义UnaryOperator。

@Override
public String apply(String var) {

    if (var == null || var.length() == 0) {
        return var;
    }
    return var.substring(0, 1).toUpperCase() + var.substring(1);
}

在UnaryOperator's apply()方法中，我们使用第一个大写字母还原字符串。

items.replaceAll(new MyOperator<>());

将运算符应用于列表项。

[Coin, Pen, Cup, Notebook, Glass]

This is the output of the example.

Java `ArrayList contains()`

如果列表包含指定的元素，则contains()方法返回 true。

com/zetcode/ContainsEx.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);
        }
    }
}

该示例检查指定的项目是否在列表中。

if (items.contains(item)) {

    System.out.printf("There is a %s in the list%n", item);
}

如果该项目在列表中，则会打印该消息。

There is a pen in the list

This is the output.

获取 ArrayList 中元素的索引

ArrayList中的每个元素都有其自己的索引号。 indexOf()返回指定元素首次出现的索引，如果列表不包含该元素，则返回-1。 lasindexOf()返回指定元素最后一次出现的索引；如果列表中不包含该元素，则返回-1。

com/zetcode/GetIndexEx.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”元素的第一个和最后一个索引。

1
4

这是示例输出。

Java 列表的列表

We can add other lists into a list.

com/zetcode/ListOfLists.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();
        }
    }
}

该示例创建三个整数列表。以后，这些列表将添加到另一个第四列表中。

List<Integer> l1 = new ArrayList<>();
l1.add(1);
l1.add(2);
l1.add(3);

将创建一个整数列表。

List<List> nums = new ArrayList<>();
nums.add(l1);
nums.add(l2);
nums.add(l3);

创建列表列表。

for (List<Integer> list : nums) {

    for (Integer n : list) {

        System.out.printf("%d ", n);
    }

    System.out.println();
}

我们使用两个 for 循环遍历所有元素。

[[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

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);
    }
}

该示例从项目列表创建子列表。

List<String> items2 = items.subList(2, 5);

使用subList()方法创建一个子列表。它包含索引为 2、3 和 4 的项目。

items2.set(0, "bottle");

我们替换子列表的第一项；修改也反映在原始列表中。

[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

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()构造的整数数组列表。

List<Integer> nums = new ArrayList<>();
nums.add(2);
nums.add(6);
nums.add(7);
nums.add(3);
nums.add(1);
nums.add(8);

我们创建了一个ArrayList整数。

for (int i = 0; i < nums.size(); i++) {

    System.out.printf("%d ", nums.get(i));
}

在这里，我们使用经典的 for 循环遍历列表。

for (int num : nums) {

    System.out.printf("%d ", num);
}

第二种方法使用 Java 5 中引入的 Enhanced-for 循环。

int j = 0;
while (j < nums.size()) {

    System.out.printf("%d ", nums.get(j));
    j++;
}

第三种方式使用 while 循环。

ListIterator<Integer> it = nums.listIterator();

while(it.hasNext()) {

    System.out.printf("%d ", it.next());
}

这里，ListIterator用于遍历列表。

nums.forEach(e -> System.out.printf("%d ", e));

最后，我们使用 Java 8 中引入的forEach()方法。

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's sort()方法根据由指定比较器引起的顺序对列表进行排序。

com/zetcode/ArrayListSortingEx.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。我们按照年龄的相反顺序对其进行排序。

persons.sort(Comparator.comparing(Person::getAge).reversed());

此行按年龄（从最大到最小）对人员进行分类。

[Age: 54 Name: Greg, Age: 47 Name: Patrick, Age: 39 Name: Robert, Age: 32 Name: Peter,
    Age: 22 Name: Mary, Age: 17 Name: Jane]

This is the output.

使用 Java 8 流对`ArrayList`进行排序

在第二个示例中，我们使用 Java 流对ArrayList进行排序。 Streams API 是一种更强大的排序方式。

com/zetcode/ArrayListSortingEx2.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;
    }
}

在此示例中，我们有一个国家/地区列表。每个国家都有名字和人口。这些国家是按人口排序的。

List<Country> sorted_countries = countries.stream()
        .sorted((e1, e2) -> Integer.compare(e1.getPopulation(),
                e2.getPopulation())).collect(Collectors.toList());

使用stream()方法，我们从列表创建流。 sorted()方法根据提供的比较器对元素进行排序。使用Integer.compare()，我们比较了国家/地区的人口。使用collect()，我们将信息流转换为国家列表。

[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

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转换为数组，反之亦然。

List<String> planets = Arrays.asList("Mercury", "Venus", "Earth",
        "Mars", "Jupiter", "Saturn", "Uranus", "Neptune");

使用Arrays.asList()方法，我们创建了一个由指定数组支持的固定大小的列表。

String[] planets2 = planets.toArray(new String[0]);

ArrayList's toArray()用于将列表转换为数组。

流到列表的转换

可以使用收集器将 Java 流转换为列表。

com/zetcode/ToList.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());
    }
}