我们可以在下面的场景中使用java流吗？

我有一个班级，比如说学生，有一个双精度的字段。我正在创建学生对象的

列表。每个学生对象可以将
标记
字段设置为
null
，或者在不同的学生对象中设置相同的值。我有一个问题，基于以下条件，我想从此
列表中返回一个学生对象：

当所有学生都有相同的
分数时
返回null
否则返回得分最高的学生
我想知道是否有更好的方法使用java流api来完成它。先谢谢你

学生班级：

public class Student {
    private Double marks;

    public Double getMarks() {
        return marks;
    }

    public void setMarks(Double marks) {
        this.marks = marks;
    }

    @Override
    public String toString() {
        return "Student [marks=" + marks + "]";
    }

    public Student(Double marks) {
        super();
        this.marks = marks;
    }
}

您可能不需要流。将列表中的最高分数排序为第一，如果前两个分数相同，则返回
null
，否则返回第一个学生

students.sort(Comparator.comparing(Student::getMarks).reversed());
boolean firstTwoHaveSameMarks = students.get(0).getMarks().equals(students.get(1).getMarks());
return firstTwoHaveSameMarks ? null : students.get(0);

如果两个或多个学生的最高分数相同，则返回null，否则返回学生。
您可以这样做：

实际上，通过使用TreeMap，您在第一个条目中获得了最高分数。所以通过检查它的值，您可以返回期望的结果。如果所有分数都具有相同的值，因此第一个条目的值必须大于一个，并且如果您有两个或多个最高分数，则第一个条目在列表中仍有多个学生对象

TreeMap<Integer, List<Student>> map = list.stream()
            .collect(Collectors.groupingBy(
                    Student::getMarks,
                    () -> new TreeMap<Integer, List<Student>>(Comparator.reverseOrder()),
                    Collectors.mapping(Function.identity(), Collectors.toList())));

Map.Entry<Integer, List<Student>> firstEntry = map.firstEntry();   
if (firstEntry.getValue().size() <= 1) {
     result = firstEntry.getValue().get(0);
}

TreeMap map=list.stream（）
.collect（收集器.groupingBy(
学生：获得分数，
（）->新树映射（Comparator.reverseOrder（）），
Collectors.mapping（Function.identity（），Collectors.toList（））；
Map.Entry firstEntry=Map.firstEntry（）；
如果（firstEntry.getValue（）.size（），您可以使用streams，但需要一个能够收集数据的助手对象

现在的工作既可以通过复制也可以通过收集来完成

如果减价，你就可以了

students.stream().reduce(
       new Helper(),
       (helper, student) -> new Helper(helper, student));

class Helper {
    private Student bestStudent = null;
    private boolean different = false;
    public Helper() {
    }
    public Helper(Helper oldHelper, Student newStudent) {
        if (oldHelper.bestStudent == null) {
            bestStudent = newStudent;
        } else if (student.getMark() > oldHelper.bestStudent.getMark()) {
            different = true;
            bestStudent = student;
        } else if (student.getMark() < oldHelper.bestStudent.getMark()) {
            different = true;
        }
    }
    public Student getResult() {
        return different ? bestStudent : null;
    }
}

students.stream（）.reduce(
新助手（），
（助手，学生）->新助手（助手，学生））；
类助手{
私人学生bestStudent=null；
private boolean different=false；
公共助理（）{
}
公共助手（助手oldHelper、学生新闻学生）{
if（oldHelper.bestStudent==null）{
最佳学生=新闻学生；
}else if（student.getMark（）>oldHelper.bestStudent.getMark（））{
不同=正确；
最佳学生=学生；
}else if（student.getMark（）

但这会为每个学生创建一个新的帮助对象

有了收集，我们就可以了

students.stream().collect(Helper::new, Helper::accept, Helper::combine);

class Helper {
    private Student bestStudent = null;
    private boolean different = false;
    public Helper() {
    }
    public void accept(Student newStudent) {
        if (bestStudent == null) {
            bestStudent = newStudent;
        } else if (newStudent.getMark() > bestStudent.getMark()) {
            different = true;
            bestStudent = newStudent;
        } else if (newStudent.getMark() < bestStudent.getMark()) {
            different = true;
        }
    }
    public void combine() (Helper other) {
        if (bestStudent == null) {
            bestStudent = other.bestStudent;
            different = other.different;
        } else if (other.bestStudent != null && other.bestStudent.getMark() > bestStudent.getMark()) {
            different = true;
            bestStudent = other.bestStudent;
        } else if (other.bestStudent != null && other.bestStudent.getMark() < bestStudent.getMark()) {
            different = true;
        }
    }
    public Student getResult() {
        return different ? bestStudent : null;
    }
}

students.stream（）.collect（Helper:：new，Helper:：accept，Helper:：combine）；
类助手{
私人学生bestStudent=null；
private boolean different=false；
公共助理（）{
}
公共无效接受（学生新闻学生）{
如果（bestStudent==null）{
最佳学生=新闻学生；
}else if（newStudent.getMark（）>bestStudent.getMark（））{
不同=正确；
最佳学生=新闻学生；
}else if（newStudent.getMark（）bestststudent.getMark（））{
不同=正确；
bestStudent=other.bestStudent；
}else if（other.bestststudent！=null&&other.bestststudent.getMark（）

（注意：1.代码未测试，2.基本逻辑的一部分取自。）
使用流s，您可以在收集到树映射并验证最新条目时执行此操作，如：

private Student highestMarkUniqueStudent(List<Student> studentList) {
    if(studentList.size() == 0) return null;
    if(studentList.size() == 1) return studentList.get(0);
    TreeMap<Integer, List<Student>> map = new TreeMap<>(studentList.stream()
            .collect(Collectors.groupingBy(Student::getMarks)));

    List<Student> highestMarkStudents = map.lastEntry().getValue();
    // only one highest or all same marks or more than one with highest mark
    return highestMarkStudents.size() == 1 ? highestMarkStudents.get(0) : null; 
}

private Student highestMarkUniqueStudent（列出studentList）{
if（studentList.size（）=0）返回null；
if（studentList.size（）==1）返回studentList.get（0）；
TreeMap map=newtreemap（studentList.stream（）
.collect（Collectors.groupingBy（Student:：getMarks））；
List highestMarkStudents=map.lastEntry（）.getValue（）；
//只有一个最高分数或所有相同分数，或有多个最高分数
返回highestMarkStudents.size（）==1？highestMarkStudents.get（0）：null；
}
对于2，1似乎是多余的。为什么要对2名学生进行特殊检查？如果5名学生中有2名得分最高怎么办？也返回null？@Bentaye如果5名学生中有2名得分最高，但相等，那么我们也需要返回null。你能展示你的
学生
班级吗？你的问题陈述不清楚，真的。1和2不清楚与您的评论相关…因此请更准确。根据OP，如果所有学生都有相同的分数，那么它必须返回Null，因为它大约是最高分数，而且有，构建mapI应该不会这么复杂。在我看来，这种情况很少发生，而且会使您的登录变得如此冗长。因此，与其选中
studentList
size drop
if（map.size（）@HadiJ是有意义的，为与
null
相同的返回类型编辑了答案。对于
collect
实现的后期，考虑到这个更干净的工具，我已经反转了实现，如果您能够通过一些有用的链接来支持这个建议，那就太好了。我认为通过使用它，可以灵活地使用cus汤姆·比较仪。不过，你的答案很好！