Java 8：如何根据保留顺序的多个属性从列表中删除重复项

Question

我正在尝试从基于多个属性的学生对象列表中删除重复项，同时保留顺序，如下所示，我有一个学生对象列表，其中我们有多个同名且出勤率不同的学生...我需要删除同名且 studentAttendence 为 100 的重复学生，同时保留顺序。

Student{studentId=1, studentName='Sam', studentAttendence=100, studentAddress='New York'}
Student{studentId=2, studentName='Sam', studentAttendence=50, studentAddress='New York'}
Student{studentId=3, studentName='Sam', studentAttendence=60, studentAddress='New York'}
Student{studentId=4, studentName='Nathan', studentAttendence=40, studentAddress='LA'}
Student{studentId=5, studentName='Ronan', studentAttendence=100, studentAddress='Atlanta'}
Student{studentId=6, studentName='Nathan', studentAttendence=100, studentAddress='LA'}

去除重复后的输出：

Student{studentId=2, studentName='Sam', studentAttendence=50, studentAddress='New York'}
Student{studentId=3, studentName='Sam', studentAttendence=60, studentAddress='New York'}
Student{studentId=4, studentName='Nathan', studentAttendence=40, studentAddress='LA'}
Student{studentId=5, studentName='Ronan', studentAttendence=100, studentAddress='Atlanta'}

我现在只根据名称删除重复项，而不考虑百分比（100）......也没有保留订单......非常感谢任何帮助。（学生供应商是一个简单的供应商功能学生名单）

studentsSupplier.get().stream()
                .sorted(Comparator.comparing(Student::getStudentName))
                .collect(Collectors.collectingAndThen(
                        Collectors.toCollection(
                                () -> new TreeSet<>(Comparator.comparing(Student::getStudentName))), ArrayList::new));

注意：只有学生姓名匹配且百分比为 100 的重复记录必须删除，（记录 Ronon 的百分比为 100 但没有相同学生姓名的重复记录，因此不能删除）

Answer 1

如果你想保持秩序，显然不要打电话给.sorted，这会扰乱秩序。

这里更普遍地使用流是复杂的。如果您要对流中的每个元素执行的操作是独立的，则流喜欢它（除了正在考虑的一个元素之外，不需要查看任何内容，即无需查看邻居）。这里不是这样。

如果删除出勤率为 100 的 任何 学生是正确的（顺便说一句，这是一个错字，正确的词是出勤率），那么所有关于“重复”的内容都是红色的鲱鱼，你只需要：

list.removeIf(s -> s.getStudentAttendence() >= 100);

但如果想法是：仅在出席人数超过 100 人时删除一条记录，并且列表中至少有一条其他同名记录，它会变得更加复杂。

主要问题是您的数据存储机制不适合这项工作。如果您只是停止使用 lambda，这并不难。将您的列表视为包含 1 亿个条目会有所帮助。对于整个流操作来说，将 1 亿个条目的名称保存在“内存”中显然是不可行的。你没有那么多记忆。数据结构（List）也不提供任何快速查找；没有办法编写代码来回答“这个列表中有多少条studentName Sam 的记录？）而不遍历1 亿个条目，这是一项非常重要的工作。

因此，鉴于以下限制：

• 输入数据为List形式。
• 输入数据尚未排序。
• 输出必须与输入保持相同的顺序。

那么从表面上看，这项工作不可能！

因此，相反，您需要接受这不是一个简单的单行程序，并且您需要首先制作确实存储您需要的相同数据存储的替代版本。

还有其他问题。特别是，如果您有 3 个Sam 学生并且每条记录都有studentAttendence = 100，会发生什么情况？应该全部删除吗？不应该删除吗？删除2个任意的？

通常，如果您在编写算法时遇到问题，实际问题是您没有完全指定您想要的行为，因此您的挣扎主要是因为您没有完全理解问题，而不仅仅是编码问题。

假设规则很简单：删除所有出勤率 = 100 的学生，但前提是存在出勤率低于 100 的同名记录。如果所有记录的出勤率都为 100，则保留所有记录，然后：

List<Students> students = ...;
Set<String> dupeNames = students.stream()
  .filter(s -> s.getAttendence() < 100)
  .map(Student::getStudentName)
  .collect(Collectors.toSet());

students.removeIf(s -> s.getAttendence() < 100 && dupeNames.contains(s.getStudentName());

会完成这项工作，而且会很快完成。 （O(n)，具体到算法上：制作基于集合的副本需要每个学生记录的固定时间步长，因此 O(n)，并且 removeIf 调用同样需要检查每个学生，但只需要执行固定时间每一步工作，因为 .contains() 在集合上是恒定时间，假设良好的哈希分布，字符串通常具有），因此，恒定数量的 O(n) 操作意味着整个操作是 O(n)：它花费的时间随着输入列表中的学生数量线性增长（与每次处理列表中的单个条目时扫描整个列表的解决方案相比，它随着输入大小的平方而增长）。

Answer 2

假设 studentId 是示例中给出的唯一性，您可以使用方法 List.removeIf 和 BiPredicate 接受学生和学生列表。

BiPredicate<Student,List<Student>> pred = 
    (stud,list) -> list.stream()
                       .filter(s -> s.getStudentId() != stud.getStudentId())
                       .anyMatch(s -> s.getStudentName().equals(stud.getStudentName()) && stud.getStudentAttendence() == 100);

students.removeIf(stud -> pred.test(stud, students));

Answer 3

你应该像这样过滤记录：

studentList.stream().filter(s -> s.getStudentAttendence() != 100)
                .filter(distinctByKeys(Student::getStudentName, Student::getStudentAttendence))
                .collect(Collectors.toList());

distinctByKeys 方法：

private static <T> Predicate<T> distinctByKeys(Function<? super T, ?>... keyExtractors) {
        final Map<List<?>, Boolean> seen = new ConcurrentHashMap<>();

        return t -> {
            final List<?> keys = Arrays.stream(keyExtractors).map(ke -> ke.apply(t)).collect(Collectors.toList());

            return seen.putIfAbsent(keys, Boolean.TRUE) == null;
        };
    }

过滤后

[Student [studentId=2, studentName=Sam, studentAttendence=50, studentAddress=New York], 
Student [studentId=3, studentName=Sam, studentAttendence=60, studentAddress=New York], 
Student [studentId=4, studentName=Nathan, studentAttendence=40, studentAddress=LA], 
Student [studentId=5, studentName=Ronan, studentAttendence=76, studentAddress=Atlanta]]

Answer 4

试试这个：

Map<String, Integer> checkList = new HashMap<>();
Student [] buffer = studentsSupplier.get()
    .stream()
    .map( student -> 
    {
        checkList.compute( student.getStudentName(), (v,k) -> (v == null) ? Integer.valueOf( 1 ) : Integer.valueOf( v.intValue() + 1 ) );
        return student;
    }
    .toArray( Student []::new );
List<Student> result = buffer.stream()
    .filter( student -> (checkList.get( student.getStudentName() ).intValue() == 1) || (student.getAttendance() != 100) )
    .collect( Collectors.toList() );

假设出勤率为 100 的记录保留在列表中，如果该记录是该学生的唯一记录。

相同代码的讨厌版本看起来像这样，但更难理解：

Map<String, Integer> checkList = new HashMap<>();
List<Student> result = studentsSupplier.get()
    .stream()
    .peek( student -> checkList.compute( student.getStudentName(), (v,k) -> (v == null) ? Integer.valueOf( 1 ) : Integer.valueOf( v.intValue() + 1 ) )
    .collect( Collectors.toList() )
    .stream()
    .filter( student -> (checkList.get( student.getStudentName() ).intValue() == 1) || (student.getAttendance() != 100) )
    .collect( Collectors.toList() );