虽然迟到了，但我有时会用这句俏皮话作为等效:

((Function<Value, Key>) Value::getKey).andThen(new HashSet<>()::add)::apply

表达式是Predicate<Value>，但由于映射是内联的，所以它作为过滤器工作。这当然可读性较差，但有时避免使用这种方法是有帮助的。

您可以将person对象包装到另一个类中，该类只比较person的名称。之后，您将打开被包装的对象以再次获得人员流。流操作可能如下所示:

persons.stream()
    .map(Wrapper::new)
    .distinct()
    .map(Wrapper::unwrap)
    ...;

类Wrapper可能看起来如下所示:

class Wrapper {
    private final Person person;
    public Wrapper(Person person) {
        this.person = person;
    }
    public Person unwrap() {
        return person;
    }
    public boolean equals(Object other) {
        if (other instanceof Wrapper) {
            return ((Wrapper) other).person.getName().equals(person.getName());
        } else {
            return false;
        }
    }
    public int hashCode() {
        return person.getName().hashCode();
    }
}

另一个支持这个的库是jOOλ，它的Seq.distinct(Function<T,U>)方法:

Seq.seq(persons).distinct(Person::getName).toList();

实际上，它所做的事情与公认的答案几乎相同。

将distinct视为一个有状态过滤器。下面是一个函数，它返回一个谓词，该谓词维护之前所见内容的状态，并返回给定元素是否第一次被看到:

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}

然后你可以这样写:

persons.stream().filter(distinctByKey(Person::getName))

注意，如果流是有序的并且是并行运行的，这将保留副本中的任意一个元素，而不是像distinct()那样保留第一个元素。

(这本质上与我对这个问题的回答相同:Java Lambda Stream Distinct()对任意键?)

另一种方法是将人名作为键放在地图中:

persons.collect(Collectors.toMap(Person::getName, p -> p, (p, q) -> p)).values();

注意，如果名称重复，则保留的Person将是第一个遇到的Person。

Set<YourPropertyType> set = new HashSet<>();
list
        .stream()
        .filter(it -> set.add(it.getYourProperty()))
        .forEach(it -> ...);