# 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)。