正如你所指出的，流和过滤是要走的路：

List<Person> filteredList =
    personList.stream()
              .filter(p -> p.getID().equals("1"))
              .collect(Collectors.toList());

字符串
如果你必须有一个ArrayList，而不是任何旧的列表（这可能不是一个好主意，例如What does it mean to "program to an interface"?），你可以使用toCollection而不是toList：

ArrayList<Person> filteredArrayList =
    personList.stream()
              .filter(p -> p.getID().equals("1"))
              .collect(Collectors.toCollection(ArrayList::new));

型

正如你提到的，你也可以用收藏的方式。这种方式更清晰，更容易，更简短。

// Sorting based on ID
Collections.sort(personList, Comparator.comparing(Person::getID));

字符串

要过滤personList以获得仅包含ID为“1”的人员的新ArrayList，可以使用Java流和filter方法。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
 public static void main(String[] args) {
    ArrayList<Person> personList = new ArrayList<>();
    personList.add(new Person("1","John", 25));
    personList.add(new Person("2","Alice", 30));
    personList.add(new Person("3","Bob", 28));
    // Filter persons with ID "1"
    List<Person> filteredPersonList = personList.stream()
            .filter(person -> person.getID().equals("1"))
            .collect(Collectors.toList());
    // Print the filtered persons
    for (Person person : filteredPersonList) {
        System.out.println("ID: " + person.getID() + ", Name: " + person.getName() + ", Age: " + person.getAge());
    }
 }
}

字符串

在现代Java（JDK 17/21）中过滤List的正确方法如下：

import java.util.List;
public class FilterById {
    record Person(String id, String name, int age) {}
    public static void main(String[] args) {
        List<Person> people = List.of(
                new Person("1", "John", 25),
                new Person("2", "Alice", 30),
                new Person("3", "Bob", 28)
        );
        List<Person> peopleWithAnIdOfOne = people.stream()
                .filter(p -> p.id.equals("1"))
                .toList();
        System.out.println(peopleWithAnIdOfOne); // [Person[id=1, name=John, age=25]]
    }
}

字符串
这是一种函数式方法。过滤后的结果是原始列表的不可变副本。我使用以下代码简化了这一点：

• a Personrecord（JDK 14）
• 一个不可变的输入列表~ List.of（JDK 9）
• 不可变的输出列表~ Stream::toList（JDK 16）

可变性

我们甚至根本不需要显式地使用ArrayList。除非你需要修改结果，否则你应该将结果集合传递给一个新的ArrayList。

List<Person> filteredPeople = new ArrayList<>(peopleWithAnIdOfOne); // Mutable list

型

高级用法

如果你想合并组合一个访问器/Map器和一个 predicate ，你可以尝试下面的方法。

**注意：**这不适用于记录，因为Person::age不能从静态上下文引用。您将需要像Person::getAge这样的方法访问器。

import lombok.Value;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
public class FilterById {
    @Value
    static class Person {
        String id, name;
        int age;
    }
    // As a predicate functional interface
    private static final Predicate<Integer> isOlderThan25 = age -> age > 25;
    // As a static method
    private static boolean isOlderThan25(int age) {
        return age > 25;
    }
    private static final List<Person> people = List.of(
            new Person("1", "John", 25),
            new Person("2", "Alice", 30),
            new Person("3", "Bob", 28)
    );
    public static void main(String[] args) {
        {
            // Predicate functional interface
            List<Person> peopleOlderThan25 = people.stream()
                    .filter(comparator(Person::getAge, FilterById::isOlderThan25))
                    .toList();
            System.out.println(peopleOlderThan25);
        }
        {
            // Static method
            List<Person> peopleOlderThan25 = people.stream()
                    .filter(comparator(Person::getAge, isOlderThan25))
                    .toList();
            System.out.println(peopleOlderThan25);
        }
    }
    // Generic utility method that accepts a mapper and a predicate
    public static <T, R> Predicate<T> comparator(Function<T, R> mapper, Predicate<R> predicate) {
        return item -> predicate.test(mapper.apply(item));
    }
}

型