在DTO上使用lamda表达式的流

Question

我有学生类的数组。学生类有两个字段1.private最后的字符串firstName；2.private最后的布尔值是当前；

如果学生处于非活动状态，在学生类中出现的检查当前api将给出错误的值。

下面是我的DTO课程。

/**
* A class representing a single student in a single class.
*/
public final class Student2 {
/**
 * First name of the student.
 */
private final String firstName;
/**
 * Whether the student is currently enrolled, or has already completed the
 * course.
 */
private final boolean isCurrent;

/**
 * Constructor.
 * @param setFirstName Student first name
 * @param setIsCurrent Student currently enrolled?
 */
public Student2(final String setFirstName,final boolean setIsCurrent) {
    this.firstName = setFirstName;
    this.isCurrent = setIsCurrent;
}

/**
 * Get the first name of this student.
 * @return The student's first name.
 */
public String getFirstName() {
    return firstName;
}


/**
 * Check if this student is active, or has taken the course in the past.
 * @return true if the student is currently enrolled, false otherwise
 */
public boolean checkIsCurrent() {
    return isCurrent;
}
}

现在我想知道最常见的不活跃学生的名字？

我想这样做，与平行流？

 public String mostCommonFirstNameOfInactiveStudentsParallelStream(final Student[] studentArray) {
       try{
            return Stream.of(studentArray)
                     .parallel()
                     .filter(s->!s.checkIsCurrent())
                     .map(s->s.getFirstName())                   
          }
          catch(Exception e){
             throw e;
          }
 }

什么是并行流代码？

Answer 1

可以使用group pingBy收集器：

   return Stream.of(studentArray)
                .parallel()
                .filter(s -> !s.checkIsCurrent()) 
                .map(Student::getFirstName())   
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                .entrySet()
                .stream()
                .min(Map.Entry.<String, Long>comparingByValue().reversed())
                .map(Entry::getKey).orElse(null);

另一个选项是使用Collections.frequency，尽管这需要覆盖equals/hashcode。

Answer 2

您应该决定您的类是学生还是学生。此外，不要插入任意的代码块。

实现这一目标的一种方法是

public String mostCommonFirstNameOfInactiveStudentsParallelStream(Student2[] studentArray){
    return Arrays.stream(studentArray)
             .parallel()
             .filter(s->!s.checkIsCurrent())
             .collect(Collectors.toMap(Student2::getFirstName, s -> 1, Integer::sum))
             .entrySet().stream()
             .max(Map.Entry.comparingByValue())
             .map(Map.Entry::getKey)
             .orElse(null);
}

另一种选择是

public String mostCommonFirstNameOfInactiveStudentsParallelStream(Student2[] studentArray){
    return Arrays.stream(studentArray)
             .parallel()
             .filter(s->!s.checkIsCurrent())
             .collect(Collectors.groupingByConcurrent(Student2::getFirstName,
                                                      Collectors.summingInt(s -> 1)))
             .entrySet().stream()
             .max(Map.Entry.comparingByValue())
             .map(Map.Entry::getKey)
             .orElse(null);
}

哪一个更快，取决于几种情况。您还可以将toMap替换为toConcurrentMap，或将groupingByConcurrent替换为groupingBy，最终得到四个备选测试。

但最有可能的是，顺序流无论如何都会比并行流快，因为不太可能有这么多对象，并行处理会有回报。