基于 Java 8 中的属性从对象列表中删除重复项 [重复]

Question

我正在尝试根据某些属性从对象列表中删除重复项。

我们可以使用 java 8 以简单的方式做到这一点

List<Employee> employee

我们可以根据员工的id 属性从中删除重复项吗？我已经看到从字符串数组列表中删除重复字符串的帖子。

Answer 1

您可以从List 获取一个流并放入TreeSet，您可以从中提供一个自定义比较器来唯一地比较id。

如果你真的需要一个列表，你可以把这个集合放回一个 ArrayList。

import static java.util.Comparator.comparingInt;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;

...
List<Employee> unique = employee.stream()
                                .collect(collectingAndThen(toCollection(() -> new TreeSet<>(comparingInt(Employee::getId))),
                                                           ArrayList::new));

举个例子：

List<Employee> employee = Arrays.asList(new Employee(1, "John"), new Employee(1, "Bob"), new Employee(2, "Alice"));

它会输出：

[Employee{id=1, name='John'}, Employee{id=2, name='Alice'}]

---

另一个想法可能是使用包装器来包装员工，并使用基于其 id 的 equals 和 hashcode 方法：

class WrapperEmployee {
    private Employee e;

    public WrapperEmployee(Employee e) {
        this.e = e;
    }

    public Employee unwrap() {
        return this.e;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        WrapperEmployee that = (WrapperEmployee) o;
        return Objects.equals(e.getId(), that.e.getId());
    }

    @Override
    public int hashCode() {
        return Objects.hash(e.getId());
    }
}

然后你包装每个实例，调用distinct()，打开它们并将结果收集到一个列表中。

List<Employee> unique = employee.stream()
                                .map(WrapperEmployee::new)
                                .distinct()
                                .map(WrapperEmployee::unwrap)
                                .collect(Collectors.toList());

---

事实上，我认为你可以通过提供一个进行比较的函数来使这个包装器通用：

public class Wrapper<T, U> {
    private T t;
    private Function<T, U> equalityFunction;

    public Wrapper(T t, Function<T, U> equalityFunction) {
        this.t = t;
        this.equalityFunction = equalityFunction;
    }

    public T unwrap() {
        return this.t;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        @SuppressWarnings("unchecked")
        Wrapper<T, U> that = (Wrapper<T, U>) o;
        return Objects.equals(equalityFunction.apply(this.t), that.equalityFunction.apply(that.t));
    }

    @Override
    public int hashCode() {
        return Objects.hash(equalityFunction.apply(this.t));
    }
}

映射将是：

.map(e -> new Wrapper<>(e, Employee::getId))

Answer 2

直接在列表中做最简单的方法是

HashSet<Object> seen=new HashSet<>();
employee.removeIf(e->!seen.add(e.getID()));

• removeIf 将删除满足指定条件的元素
• 如果Set.add没有修改Set，则Set.add将返回false，即已经包含该值
• 结合这两者，它将删除之前遇到过id的所有元素（员工）

当然，它只有在列表支持删除元素时才有效。

Answer 3

如果您可以使用equals，请在流中使用distinct 过滤列表（请参阅上面的答案）。如果您不能或不想覆盖 equals 方法，您可以通过以下方式为任何属性 filter 流，例如属性名称（属性 ID 等相同）：

Set<String> nameSet = new HashSet<>();
List<Employee> employeesDistinctByName = employees.stream()
            .filter(e -> nameSet.add(e.getName()))
            .collect(Collectors.toList());

Answer 4

另一种解决方案是使用 Predicate，然后您可以在任何过滤器中使用它：

public static <T> Predicate<T> distinctBy(Function<? super T, ?> f) {
  Set<Object> objects = new ConcurrentHashSet<>();
  return t -> objects.add(f.apply(t));
}

然后在任何地方简单地重用谓词：

employees.stream().filter(distinctBy(e -> e.getId));

注意：在过滤器的 JavaDoc 中，它说它需要一个无状态的 Predicte。实际上，即使流是并行的，这也能正常工作。

关于其他解决方案：

1) 使用.collect(Collectors.toConcurrentMap(..)).values() 是一个很好的解决方案，但如果你想排序并保持顺序，那就很烦人了。

2) stream.removeIf(e->!seen.add(e.getID())); 也是另一个非常好的解决方案。但是我们需要确保集合实现了removeIf，例如如果我们使用Arrays.asList(..)构造集合会抛出异常。

Answer 5

试试这个代码：

Collection<Employee> nonDuplicatedEmployees = employees.stream()
   .<Map<Integer, Employee>> collect(HashMap::new,(m,e)->m.put(e.getId(), e), Map::putAll)
   .values();

Answer 6

这对我有用：

list.stream().distinct().collect(Collectors.toList());

当然，你需要实现equals

Answer 7

如果顺序无关紧要并且并行运行的性能更高，则收集到地图然后获取值：

employee.stream().collect(Collectors.toConcurrentMap(Employee::getId, Function.identity(), (p, q) -> p)).values()

Answer 8

这里有很多好的答案，但我没有找到关于使用reduce 方法的答案。因此，对于您的情况，您可以通过以下方式应用它：

 List<Employee> employeeList = employees.stream()
      .reduce(new ArrayList<>(), (List<Employee> accumulator, Employee employee) ->
      {
        if (accumulator.stream().noneMatch(emp -> emp.getId().equals(employee.getId())))
        {
          accumulator.add(employee);
        }
        return accumulator;
      }, (acc1, acc2) ->
      {
        acc1.addAll(acc2);
        return acc1;
      });

Answer 9

另一个简单的版本

BiFunction<TreeSet<Employee>,List<Employee> ,TreeSet<Employee>> appendTree = (y,x) -> (y.addAll(x))? y:y;

TreeSet<Employee> outputList = appendTree.apply(new TreeSet<Employee>(Comparator.comparing(p->p.getId())),personList);