您可以通过使用 * 四参数版本 * 的收集器toMap()来解决此问题，该版本需要以下参数：

• keyMapper -从流元素生成密钥的函数;
• *valueMapper -从流元素产生值的函数;
• mergeFunctino -负责解析Map到相同键的值的函数;
• mapFunctory -允许指定所需的Map类型。

如果您无法在ValueObject中更改equals/hashCode的实现，则可以引入一个辅助类型作为Key。

public record FirstNameLastName(String firstName, String lastName) {
    public FirstNameLastName(ValueObject value) {
        this(value.getFirstName(), value.getLastName);
    }
}

***注意：*如果您可以在firstName和lastName上覆盖ValueObject的equals/hashCode协定，则不需要上面显示的辅助类型。在下面的代码中，您可以将Function.identity()用作toMap()的keyMapper和valueMapper。

流可以这样实现：

SampleClass listWithDuplicates = // initializing your domain object
    
List<ValueObject> uniqueValues = listWithDuplicates.getValues().stream()
    .collect(Collectors.toMap(
        FirstNameLastName::new, // keyMapper - creating Keys
        Function.identity(),    // valueMapper - generating Values
        (left, right) -> right  // mergeFunction - resolving duplicates
        LinkedHashMap::new      // mapFuctory - LinkedHashMap is needed to preserve the encounter order of the elements
    ))
    .values().stream()
    .toList();

您可以覆盖ValueObject类中的equals和hashCode方法（未测试）：

public class ValueObject {

    private String firstName;
    private String lastName;
    private String adress;

    // Constructor...

    // Getters and setters...

    @Override
    public boolean equals(Object obj) {
        return obj == this ||(obj instanceof ValueObject
                    && ((ValueObject) obj).firstName.equals(this.firstName)
                    && ((ValueObject) obj).lastName.equals(this.lastName)
                );
    }

    @Override
    public int hashCode() {
        return (firstName + lastName).hashCode();
    }
    
}

然后，您所需要的就是使用Stream#distinct删除重复项

listWithDuplicates.getValues().stream().distinct()
                .collect(Collectors.groupingBy(ValueObject::getLastname, Collectors.toList()));

您可以阅读this answer以获得更多有关的信息。

我不能把它放到流中，但是如果你真的在valueObject中创建了一个基于name和firstname的equals方法，你可以基于对象进行过滤，把这个放在ValueObject中：

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ValueObject that = (ValueObject) o;
        return Objects.equals(firstName, that.firstName) && Objects.equals(lastName, that.lastName);
    }

那么你应该可以很好地使用这样的循环：

List<ValueObject> listWithoutDuplicates = new ArrayList<>();

for(var vo: listWithDuplicates){
   if(!listWithoutDuplicates.contains(vo)){
        listWithoutDuplicates.add(vo);
         }
 }

但是在流中会更好，..但是如果你实现了equals方法，你可以解决这个问题。

我喜欢已经提供的答案，并认为它们为您给予了答案，但也许出于学习的目的，另一种方法可以是使用Collector，它比较每个ValueObject的firstName和lastName字段，然后只保留最后一个重复的示例。

List<ValueObject> filteredList = listWithDuplicates.getValues().stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toMap(
            vo -> vo.getLastName() + vo.getFirstName(), 
            vo -> vo, 
            (vo1, vo2) -> vo2
        ), 
        map -> new ArrayList<>(map.values())
    ));

因此，您可以使用一个COllector按lastName和firstName对ValueObject示例进行分组，该COllector创建一个Map，该Map的键是连接在一起的lastName和firstName。collectingAndThen收集器将Map转换为ValueObject列表。