原文：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

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class ListAddItem {
  8.     public static void main(String[] args) {
  10.         List<String> langs = new ArrayList<>();
  12.         langs.add("Java");
  13.         langs.add("Python");
  14.         langs.add(1, "C#");
  15.         langs.add(0, "Ruby");
  17.         for (String lang : langs) {
  19.             System.out.printf("%s ", lang);
  20.         }
  22.         System.out.println();
  23.     }
  24. }

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

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

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

  1. langs.add("Java");

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

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

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

  1. for (String lang : langs) {
  3.     System.out.printf("%s ", lang);
  4. }

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

  1. Ruby Java C# Python

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

Java 列表

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

com/zetcode/ListOf.java

  1. package com.zetcode;
  3. import java.util.List;
  5. public class ListOf {
  7.     public static void main(String[] args) {
  9.         var words = List.of("wood", "forest", "falcon", "eagle");
  10.         System.out.println(words);
  12.         var values = List.of(1, 2, 3);
  13.         System.out.println(values);
  14.     }
  15. }

在示例中，我们创建了两个包含四个和三个元素的列表。

Java ArrayList get()和size()

get()返回此列表中指定位置的元素，size()返回列表的大小。

com/zetcode/GetAndSizeEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class GetAndSizeEx {
  8.     public static void main(String[] args) {
  10.         List<String> colours = new ArrayList<>();
  12.         colours.add("blue");
  13.         colours.add("orange");
  14.         colours.add("red");
  15.         colours.add("green");
  17.         String col = colours.get(1);
  18.         System.out.println(col);
  20.         int size = colours.size();
  22.         System.out.printf("The size of the ArrayList is: %d%n", size  );
  23.     }
  24. }

该示例使用了ArrayList的get()和size()方法

  1. String col = colours.get(1);

get()方法返回第二个元素，即"orange"。

  1. int size = colours.size();

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

  1. orange
  2. The size of the ArrayList is: 4

这是示例的输出。

Java ArrayList复制

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

com/zetcode/ListCopy.java

  1. package com.zetcode;
  3. import java.util.List;
  5. public class ListCopy {
  7.     public static void main(String[] args) {
  9.         var words = List.of("forest", "wood", "eagle", "sky", "cloud");
  10.         System.out.println(words);
  12.         var words2 = List.copyOf(words);
  13.         System.out.println(words2);
  14.     }
  15. }

该示例使用List.copy()创建列表的副本。

原始ArrayList

ArrayList可以包含各种数据类型。 这些称为原始列表。

注意：通常不建议使用原始列表。

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

com/zetcode/DataTypesEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. class Base {}
  8. enum Level {
  10.     EASY,
  11.     MEDIUM,
  12.     HARD
  13. }
  15. public class DataTypesEx {
  17.     public static void main(String[] args) {
  19.         Level level = Level.EASY;
  21.         List da = new ArrayList();
  23.         da.add("Java");
  24.         da.add(3.5);
  25.         da.add(55);
  26.         da.add(new Base());
  27.         da.add(level);
  29.         for (Object el : da) {
  31.             System.out.println(el);
  32.         }
  33.     }
  35. }

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

  1. List da = new ArrayList();

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

  1. Java
  2. 3.5
  3. 55
  4. com.zetcode.Base@659e0bfd
  5. EASY

这是输出。

Java ArrayList添加多个元素

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

com/zetcode/AddingMultipleItemsEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class AddingMultipleItemsEx {
  8.     public static void main(String[] args) {
  10.         List<String> colours1 = new ArrayList<>();
  12.         colours1.add("blue");
  13.         colours1.add("red");
  14.         colours1.add("green");
  16.         List<String> colours2 = new ArrayList<>();
  18.         colours2.add("yellow");
  19.         colours2.add("pink");
  20.         colours2.add("brown");
  22.         List<String> colours3 = new ArrayList<>();
  23.         colours3.add("white");
  24.         colours3.add("orange");
  26.         colours3.addAll(colours1);
  27.         colours3.addAll(2, colours2);
  29.         for (String col : colours3) {
  31.             System.out.println(col);
  32.         }
  33.     }
  34. }

创建两个列表。 稍后，使用addAll()方法将列表中的元素添加到第三个列表中。

  1. colours3.addAll(colours1);

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

  1. colours3.addAll(2, colours2);

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

  1. white
  2. orange
  3. yellow
  4. pink
  5. brown
  6. blue
  7. red
  8. green

This is the output of the example.

Java ArrayList修改元素

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

com/zetcode/ModifyingListEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class ModifyingListEx {
  8.     public static void main(String[] args) {
  10.         List<String> items = new ArrayList<>();
  11.         fillList(items);
  13.         items.set(3, "watch");
  14.         items.add("bowl");
  15.         items.remove(0);
  16.         items.remove("pen");
  18.         for (Object el : items) {
  20.             System.out.println(el);
  21.         }
  23.         items.clear();
  25.         if (items.isEmpty()) {
  27.             System.out.println("The list is empty");
  28.         } else {
  29.             System.out.println("The list is not empty");
  30.         }
  31.     }
  33.     public static void fillList(List<String> list) {
  35.         list.add("coin");
  36.         list.add("pen");
  37.         list.add("pencil");
  38.         list.add("clock");
  39.         list.add("book");
  40.         list.add("spectacles");
  41.         list.add("glass");
  42.     }
  43. }

使用set()，add()，remove()和clear()方法创建和修改ArrayList。

  1. items.set(3, "watch");

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

  1. items.add("bowl");

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

  1. items.remove(0);

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

  1. items.remove("pen");

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

  1. items.clear();

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

  1. if (items.isEmpty()) {

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

  1. pencil
  2. watch
  3. book
  4. spectacles
  5. glass
  6. bowl
  7. The list is empty

This is the output of the example.

Java ArrayList removeIf

removeIf()方法删除满足给定谓词的集合中的所有元素。

com/zetcode/RemoveIfEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class RemoveIfEx {
  8.     public static void main(String[] args) {
  10.         List<Integer> values = new ArrayList<>();
  11.         values.add(5);
  12.         values.add(-3);
  13.         values.add(2);
  14.         values.add(8);
  15.         values.add(-2);
  16.         values.add(6);
  18.         values.removeIf(val -> val < 0);
  20.         System.out.println(values);
  21.     }
  22. }

在我们的示例中，我们有一个ArrayList整数。 我们使用removeIf方法删除所有负值。

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

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

  1. [5, 2, 8, 6]

这是输出。

Java ArrayList removeAll

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

com/zetcode/RemoveAll.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  7. public class RemoveAll {
  9.     public static void main(String[] args) {
  11.         List<String> letters = new ArrayList<>();
  12.         letters.add("a");
  13.         letters.add("b");
  14.         letters.add("c");
  15.         letters.add("a");
  16.         letters.add("d");
  18.         System.out.println(letters);
  20.         letters.removeAll(Collections.singleton("a"));
  21.         System.out.println(letters);
  22.     }
  23. }

在示例中，我们从列表中删除了所有"a"字母。

Java ArrayList replaceAll

replaceAll()方法用将运算符应用于该元素的结果替换列表的每个元素。

com/zetcode/ReplaceAllEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.function.UnaryOperator;
  7. public class ReplaceAllEx {
  9.     public static void main(String[] args) {
  11.         List<String> items = new ArrayList<>();
  12.         items.add("coin");
  13.         items.add("pen");
  14.         items.add("cup");
  15.         items.add("notebook");
  16.         items.add("class");
  18.         UnaryOperator<String> uo = (x) -> x.toUpperCase();
  20.         items.replaceAll(uo);
  22.         System.out.println(items);
  23.     }
  24. }

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

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

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

  1. items.replaceAll(uo);

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

  1. [COIN, PEN, CUP, NOTEBOOK, CLASS]

这是输出。

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

com/zetcode/ReplaceAllEx2.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.function.UnaryOperator;
  7. class MyOperator<T> implements UnaryOperator<String> {
  9.     @Override
  10.     public String apply(String var) {
  12.         if (var == null || var.length() == 0) {
  13.             return var;
  14.         }
  15.         return var.substring(0, 1).toUpperCase() + var.substring(1);
  16.     }
  17. }
  19. public class ReplaceAllEx2 {
  21.     public static void main(String[] args) {
  23.         List<String> items = new ArrayList<>();
  25.         items.add("coin");
  26.         items.add("pen");
  27.         items.add("cup");
  28.         items.add("notebook");
  29.         items.add("glass");
  31.         items.replaceAll(new MyOperator<>());
  33.         System.out.println(items);
  34.     }
  35. }

我们有一个字符串项目列表。 这些项目在replaceAll()方法的帮助下大写。

  1. class MyOperator<T> implements UnaryOperator<String> {

创建自定义UnaryOperator。

  1. @Override
  2. public String apply(String var) {
  4.     if (var == null || var.length() == 0) {
  5.         return var;
  6.     }
  7.     return var.substring(0, 1).toUpperCase() + var.substring(1);
  8. }

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

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

将运算符应用于列表项。

  1. [Coin, Pen, Cup, Notebook, Glass]

This is the output of the example.

Java ArrayList.contains()

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

com/zetcode/ContainsEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class ContainsEx {
  8.     public static void main(String[] args) {
  10.         List<String> items = new ArrayList<>();
  12.         items.add("coin");
  13.         items.add("pen");
  14.         items.add("cup");
  15.         items.add("notebook");
  16.         items.add("class");
  18.         String item = "pen";
  20.         if (items.contains(item)) {
  22.             System.out.printf("There is a %s in the list%n", item);
  23.         }
  24.     }
  25. }

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

  1. if (items.contains(item)) {
  3.     System.out.printf("There is a %s in the list%n", item);
  4. }

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

  1. There is a pen in the list

这是输出。

获取ArrayList中元素的索引

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

com/zetcode/GetIndexEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class GetIndexEx {
  8.     public static void main(String[] args) {
  10.         List<String> colours = new ArrayList<>();
  12.         colours.add(0, "blue");
  13.         colours.add(1, "orange");
  14.         colours.add(2, "red");
  15.         colours.add(3, "green");
  16.         colours.add(4, "orange");
  18.         int idx1 = colours.indexOf("orange");
  19.         System.out.println(idx1);
  21.         int idx2 = colours.lastIndexOf("orange");
  22.         System.out.println(idx2);
  23.     }
  24. }

该示例打印"orange"元素的第一个和最后一个索引。

  1. 1
  2. 4

这是示例输出。

Java 列表的列表

We can add other lists into a list.

com/zetcode/ListOfLists.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class ListOfLists {
  8.     public static void main(String[] args) {
  10.         List<Integer> l1 = new ArrayList<>();
  11.         l1.add(1);
  12.         l1.add(2);
  13.         l1.add(3);
  15.         List<Integer> l2 = new ArrayList<>();
  16.         l2.add(4);
  17.         l2.add(5);
  18.         l2.add(6);
  20.         List<Integer> l3 = new ArrayList<>();
  21.         l3.add(7);
  22.         l3.add(8);
  23.         l3.add(9);
  25.         List<List<Integer>> nums = new ArrayList<>();
  26.         nums.add(l1);
  27.         nums.add(l2);
  28.         nums.add(l3);
  30.         System.out.println(nums);
  32.         for (List<Integer> list : nums) {
  34.             for (Integer n : list) {
  36.                 System.out.printf("%d ", n);
  37.             }
  39.             System.out.println();
  40.         }
  41.     }
  42. }

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

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

将创建一个整数列表。

  1. List<List> nums = new ArrayList<>();
  2. nums.add(l1);
  3. nums.add(l2);
  4. nums.add(l3);

创建列表列表。

  1. for (List<Integer> list : nums) {
  3.     for (Integer n : list) {
  5.         System.out.printf("%d ", n);
  6.     }
  8.     System.out.println();
  9. }

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

  1. [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  2. 1 2 3
  3. 4 5 6
  4. 7 8 9

这是程序的输出。

Java ArrayList子列表

subList()方法返回指定的fromIndex（包括）和toIndex（不包括）之间的列表部分的视图。 子列表中的更改将反映在原始列表中。

com/zetcode/SubListEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class SubListEx {
  8.     public static void main(String[] args) {
  10.         List<String> items = new ArrayList<>();
  12.         items.add("coin");
  13.         items.add("pen");
  14.         items.add("cup");
  15.         items.add("notebook");
  16.         items.add("glass");
  17.         items.add("chair");
  18.         items.add("ball");
  19.         items.add("bowl");
  21.         List<String> items2 = items.subList(2, 5);
  23.         System.out.println(items2);
  25.         items2.set(0, "bottle");
  27.         System.out.println(items2);
  28.         System.out.println(items);
  29.     }
  30. }

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

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

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

  1. items2.set(0, "bottle");

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

  1. [cup, notebook, glass]
  2. [bottle, notebook, glass]
  3. [coin, pen, bottle, notebook, glass, chair, ball, bowl]

This is the output of the example.

Java ArrayList遍历

在下面的示例中，我们展示了遍历ArrayList的五种方法。

com/zetcode/TraversingArrayListEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.ListIterator;
  7. public class TraversingArrayListEx {
  9.     public static void main(String[] args) {
  11.         List<Integer> nums = new ArrayList<>();
  12.         nums.add(2);
  13.         nums.add(6);
  14.         nums.add(7);
  15.         nums.add(3);
  16.         nums.add(1);
  17.         nums.add(8);
  19.         for (int i = 0; i < nums.size(); i++) {
  21.             System.out.printf("%d ", nums.get(i));
  22.         }
  24.         System.out.println();
  26.         for (int num : nums) {
  28.             System.out.printf("%d ", num);
  29.         }
  31.         System.out.println();
  33.         int j = 0;
  34.         while (j < nums.size()) {
  36.             System.out.printf("%d ", nums.get(j));
  37.             j++;
  38.         }
  40.         System.out.println();
  42.         ListIterator<Integer> it = nums.listIterator();
  44.         while(it.hasNext()) {
  46.             System.out.printf("%d ", it.next());
  47.         }
  49.         System.out.println();
  51.         nums.forEach(e -> System.out.printf("%d ", e));
  52.         System.out.println();
  53.     }
  54. }

在示例中，我们遍历具有for循环，while循环，迭代器和forEach()构造的整数数组列表。

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

我们创建了一个ArrayList整数。

  1. for (int i = 0; i < nums.size(); i++) {
  3.     System.out.printf("%d ", nums.get(i));
  4. }

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

  1. for (int num : nums) {
  3.     System.out.printf("%d ", num);
  4. }

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

  1. int j = 0;
  2. while (j < nums.size()) {
  4.     System.out.printf("%d ", nums.get(j));
  5.     j++;
  6. }

第三种方式使用while循环。

  1. ListIterator<Integer> it = nums.listIterator();
  3. while(it.hasNext()) {
  5.     System.out.printf("%d ", it.next());
  6. }

这里，ListIterator用于遍历列表。

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

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

  1. 2 6 7 3 1 8
  2. 2 6 7 3 1 8
  3. 2 6 7 3 1 8
  4. 2 6 7 3 1 8
  5. 2 6 7 3 1 8

该示例使用各种技术将列表的元素打印到控制台。

Java ArrayList排序

对ArrayList进行分类有不同的浪费。

使用其sort方法对ArrayList进行排序

ArrayList的sort()方法根据由指定比较器引起的顺序对列表进行排序。

com/zetcode/ArrayListSortingEx.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.Comparator;
  5. import java.util.List;
  7. class Person {
  9.     private int age;
  10.     private String name;
  12.     public Person(int age, String name) {
  14.         this.age = age;
  15.         this.name = name;
  16.     }
  18.     public int getAge() {
  20.         return age;
  21.     }
  23.     @Override
  24.     public String toString() {
  25.         return "Age: " + age + " Name: " + name;
  26.     }
  27. }
  29. public class ArrayListSortingEx {
  31.     public static void main(String[] args) {
  33.         List<Person> persons = createList();
  35.         persons.sort(Comparator.comparing(Person::getAge).reversed());
  37.         System.out.println(persons);
  39.     }
  41.     private static List<Person> createList() {
  43.         List<Person> persons = new ArrayList<>();
  45.         persons.add(new Person(17, "Jane"));
  46.         persons.add(new Person(32, "Peter"));
  47.         persons.add(new Person(47, "Patrick"));
  48.         persons.add(new Person(22, "Mary"));
  49.         persons.add(new Person(39, "Robert"));
  50.         persons.add(new Person(54, "Greg"));
  52.         return persons;
  53.     }
  54. }

我们有一个自定义Person类的ArrayList。 我们按照年龄的相反顺序对其进行排序。

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

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

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

这是输出。

使用 Java8 流对ArrayList进行排序

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

com/zetcode/ArrayListSortingEx2.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.stream.Collectors;
  7. class Country {
  9.     private String name;
  10.     private int population;
  12.     public Country(String name, int population) {
  13.         this.name = name;
  14.         this.population = population;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public int getPopulation() {
  26.         return population;
  27.     }
  29.     public void setPopulation(int population) {
  30.         this.population = population;
  31.     }
  33.     @Override
  34.     public String toString() {
  35.         return "Country{" + "name=" + name
  36.                 + ", population=" + population + '}';
  37.     }
  38. }
  40. public class ArrayListSortingEx2 {
  42.     public static void main(String[] args) {
  44.         List<Country> countries = createList();
  46.         List<Country> sorted_countries = countries.stream()
  47.                 .sorted((e1, e2) -> Integer.compare(e1.getPopulation(),
  48.                         e2.getPopulation())).collect(Collectors.toList());
  50.         System.out.println(sorted_countries);
  51.     }
  53.     private static List<Country> createList() {
  55.         List<Country> countries = new ArrayList<>();
  57.         countries.add(new Country("Slovakia", 5424000));
  58.         countries.add(new Country("Hungary", 9845000));
  59.         countries.add(new Country("Poland", 38485000));
  60.         countries.add(new Country("Germany", 81084000));
  61.         countries.add(new Country("Latvia", 1978000));
  63.         return countries;
  64.     }
  65. }

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

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

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

  1. [Country{name=Latvia, population=1978000}, Country{name=Slovakia, population=5424000},
  2. Country{name=Hungary, population=9845000}, Country{name=Poland, population=38485000},
  3. Country{name=Germany, population=81084000}]

这是输出。 这些国家按人口升序排序。

使用ArrayList和简单的 Java 数组

下面的示例使用带有简单 Java 数组的ArrayList。

com/zetcode/ListToArray.java

  1. package com.zetcode;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. public class ListToArray {
  8.     public static void main(String[] args) {
  10.         List<String> planets = Arrays.asList("Mercury", "Venus", "Earth",
  11.                 "Mars", "Jupiter", "Saturn", "Uranus", "Neptune");
  13.         System.out.println(planets);
  15.         String[] planets2 = planets.toArray(new String[0]);
  17.         System.out.println(Arrays.toString(planets2));
  18.     }
  19. }

ArrayList转换为数组，反之亦然。

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

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

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

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

流到列表的转换

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

com/zetcode/ToList.java

  1. package com.zetcode;
  3. import java.util.List;
  4. import java.util.stream.Collectors;
  5. import java.util.stream.Stream;
  7. public class ToList {
  9.     public static void main(String[] args) {
  11.         var words = Stream.of("forest", "eagle", "river", "cloud", "sky");
  13.         List<String> words2 = words.collect(Collectors.toList());
  14.         System.out.println(words2.getClass());
  15.     }
  16. }

我们有一串串的字符串。 我们使用Collectors.toList()将流转换为列表。

  1. class java.util.ArrayList

这是输出。

在本教程中，我们使用了 Java ArrayList容器。

您可能也对以下相关教程感兴趣： Java HashMap教程， Java HashSet教程， Java 教程， Google Guava 简介 ，在 Java 中过滤列表，或在 Java 中读取网页。

列出所有 Java 教程。