Java 使用流检索工资最低的员工列表

我正在试图从员工列表中检索工资最低的员工列表。到目前为止，我已经找到了工资最低的员工，但是如果有几个员工的工资相同，我想检索多个

我认为解决方案应该是一条线。因此，我不能创建一个工资最低的变量，只需检查每个变量的“工资低于或等于低工资”。我试过这个，它成功了

所以我认为我的问题是“.min（comparator）”只检索最低值中的一个

Comparator-Comparator=Comparator.comparating（员工：：getSalary）；
List lowSalary=employees.stream（）
.min（比较器）
.stream（）
.collect（Collectors.toList（））；
lowSalary.forEach（系统输出：：println）；

首先创建一个

树状图，其关键是工资<代码>树映射

按其键对其条目进行排序。然后抓取第一个条目，即工资最低的条目，并获取与之相关的值。此解决方案仅在列表上迭代一次。这是它的样子

List<Employee> empsWithLowestSalary = employees.stream()
    .collect(Collectors.groupingBy(Employee::getSalary, TreeMap::new, Collectors.toList()))
    .firstEntry()
    .getValue();

static <T> Collector<T, ?, List<T>> minList(Comparator<? super T> comp) {
    return Collector.of(ArrayList::new, (list, t) -> {
        int c;
        if (list.isEmpty() || (c = comp.compare(t, list.get(0))) == 0)
            list.add(t);
        else if (c < 0) {
            /*
             * We have found a smaller element than what we already have. Clear the list and
             * add this smallest element to it.
             */
            list.clear();
            list.add(t);
        }
    }, (list1, list2) -> {
        if (comp.compare(list1.get(0), list2.get(0)) < 0)
            return list1;
        else if (comp.compare(list1.get(0), list2.get(0)) > 0)
            return list2;
        else {
            list1.addAll(list2);
            return list1;
        }
    });
}

这是你的客户代码

Collection<Employee> empsWithLowestSalary = employees.stream()
                .collect(minList(Comparator.comparing(Employee::getSalary)));

Collection empsWithLowestSalary=employees.stream（）
.collect（minList（Comparator.comparing（Employee:：getSalary）））；

您可以按薪资分组，然后检索具有最低薪资的员工列表：

List<Employee> employees = new ArrayList<Employee>(){{
    add(new Employee("bilbo baggins", 10));
    add(new Employee("frodo baggins", 10));
    add(new Employee("gandalf grey", 100));
}};

Map<Integer, List<Employee>> result = employees.stream().collect(groupingBy(Employee::getSalary));

List<Employee> allMin = result.entrySet().stream()
        .min(Comparator.comparing(Map.Entry::getKey))
        .map(Map.Entry::getValue)
        .orElse(Collections.emptyList());

allMin.forEach(System.out::println);

Integer lowestSalary=employees.stream（）
.min（Comparator.comparating（员工：：getSalary））
.map（Employee:：getSalary）.get（）；
列出最低工资=employees.stream（）的员工
.filter（e->e.getSalary（）==最低工资）
.collect（Collectors.toList（））；

---

首先查找最低工资是多少，然后筛选员工列表，这样您就只有工资匹配的员工。

您可以先获取最低工资员工，然后按其进行筛选

  Comparator<Employee> comparator = Comparator.comparing( Employee :: getSalary);
        Optional<Employee> min = employees.stream()
                .min(comparator);
        List<Employee> lowSalary = employees.stream()
                .filter(ele->ele.salary==min.get().salary)
                .collect(Collectors.toList());

Comparator-Comparator=Comparator.comparating（员工：：getSalary）；
可选最小值=employees.stream（）
.min（比较器）；
List lowSalary=employees.stream（）
.filter（要素->要素薪资==min.get（）.salary）
.collect（Collectors.toList（））；

您可以先计算最低工资，然后在

流#过滤器

条件中使用它：

int salary = 
   employees.stream()
            .min(Comparator.comparing(Employee::getSalary))
            .map(e -> e.getSalary())
            .orElse(-1);

List<Employee> emps = 
  employees.stream()
           .filter(emp -> emp.getSalary() == salary)
           .collect(Collectors.toList());

int工资=
employees.stream（）
.min（Comparator.comparating（员工：：getSalary））
.map（e->e.getSalary（））
.orElse（-1）；
列表EMP=
employees.stream（）
.filter（emp->emp.getSalary（）==salary）
.collect（Collectors.toList（））；

“我认为解决方案应该在一行中。”-为什么？另请参见此解决方案的复杂性？我相信这是O（n*logn）。是的，这是排序算法的成本。回答不错。除了时间复杂度之外，据我所知，这个解决方案还需要为

groupingBy

收集器消耗额外的空间。空间复杂度是O（n），因为我们在这里存储了n个映射条目。

  Comparator<Employee> comparator = Comparator.comparing( Employee :: getSalary);
        Optional<Employee> min = employees.stream()
                .min(comparator);
        List<Employee> lowSalary = employees.stream()
                .filter(ele->ele.salary==min.get().salary)
                .collect(Collectors.toList());

int salary = 
   employees.stream()
            .min(Comparator.comparing(Employee::getSalary))
            .map(e -> e.getSalary())
            .orElse(-1);

List<Employee> emps = 
  employees.stream()
           .filter(emp -> emp.getSalary() == salary)
           .collect(Collectors.toList());