Question

我想将List<Pojo>带到其他List<Pojo> 输入如下数据：

Pojo -> type:A money:20.00
Pojo -> type:A money:10.00
Pojo -> type:B money:23.00
Pojo -> type:A money:11.00
Pojo -> type:C money:38.00
Pojo -> type:B money:233.00

输出数据如下（每种类型最大的钱）：

Pojo -> type:A money:20.00
Pojo -> type:B money:233.00
Pojo -> type:C money:38.00

那么，我如何使用lambda来完成这项工作呢？谢谢你！

Answer 1

这是一种使用max by

的方法

public class Test4 {
    public static void main(String[] args) {
        List<Pojo> pojoList = new ArrayList<>();
        pojoList.add(new Pojo("A", 20.00d));
        pojoList.add(new Pojo("A", 10.00d));
        pojoList.add(new Pojo("B", 23.00d));
        pojoList.add(new Pojo("A", 11.00d));
        pojoList.add(new Pojo("C", 38.00d));
        pojoList.add(new Pojo("B", 233.00d));
        Map<String, Optional<Pojo>> map = pojoList.stream()
                .collect(Collectors.groupingBy(Pojo::getType, Collectors.maxBy(Comparator.comparing(Pojo::getMoney))));
        List<Pojo> pojos = map.values().stream().map(Optional::get).collect(Collectors.toList());
        System.out.println(pojos);

    }

    static class Pojo {
        public String type;
        public double money;

        public Pojo(String type, double money) {
            this.type = type;
            this.money = money;
        }

        public double getMoney() {
            return money;
        }

        public String getType() {
            return type;
        }

        @Override
        public String toString() {
            return "Pojo [type=" + type + ", money=" + money + "]";
        }

    }
}

输出

[Pojo [type=A, money=20.0], Pojo [type=B, money=233.0], Pojo [type=C, money=38.0]]

<强>更新

可以使用Collectors.collectingAndThen在结果上应用函数，以获取由Optional

包装的值

进口

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.maxBy;

collectingAndThen

Map<String, Pojo> result = pojoList.stream()
        .collect(groupingBy(Pojo::getType, collectingAndThen(maxBy(comparing(Pojo::getMoney)), Optional::get)));

输出

{A=Pojo [type=A, money=20.0], B=Pojo [type=B, money=233.0], C=Pojo [type=C, money=38.0]}

Answer 2

猜猜这接近你所需要的：

    Money money1 = new Money("A", 100);
    Money money2 = new Money("A", 200);
    Money money3 = new Money("B", 300);
    Money money4 = new Money("C", 400);
    Money money5 = new Money("A", 500);
    Money money6 = new Money("B", 600);
    Money money7 = new Money("A", 700);

    List<Money> moneys = new ArrayList<Money>();

    moneys.add(money1);
    moneys.add(money2);
    moneys.add(money3);
    moneys.add(money4);
    moneys.add(money5);
    moneys.add(money6);
    moneys.add(money7);

    List<Money> maxList = new ArrayList<Money>();

    moneys.stream()
            .collect(
                    Collectors.groupingBy(Money::getType, Collectors.maxBy(Comparator.comparing(Money::getAmount))))
            .forEach((type, sumOfType) -> System.out.println(type + "\t" + sumOfType));

    moneys.stream().collect(Collectors.groupingBy(Money::getType, Collectors.maxBy(Comparator.comparing(Money::getAmount))))
            .forEach((type, max) -> maxList.add(max.get()));

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

JDK8 lambda过滤器列表到其他列表

2 个答案: