JDK12 Collectors.teeing 功能真香

/** * Returns a {@code Collector} that is a composite of two downstream collectors. * Every element passed to the resulting collector is processed by both downstream * collectors, then their results are merged using the specified merge function * into the final result. * * <p>The resulting collector functions do the following: * * <ul> * <li>supplier: creates a result container that contains result containers * obtained by calling each collector's supplier * <li>accumulator: calls each collector's accumulator with its result container * and the input element * <li>combiner: calls each collector's combiner with two result containers * <li>finisher: calls each collector's finisher with its result container, * then calls the supplied merger and returns its result. * </ul> * * <p>The resulting collector is {@link Collector.Characteristics#UNORDERED} if both downstream * collectors are unordered and {@link Collector.Characteristics#CONCURRENT} if both downstream * collectors are concurrent. * * @param <T>         the type of the input elements * @param <R1>        the result type of the first collector * @param <R2>        the result type of the second collector * @param <R>         the final result type * @param downstream1 the first downstream collector * @param downstream2 the second downstream collector * @param merger      the function which merges two results into the single one * @return a {@code Collector} which aggregates the results of two supplied collectors. * @since 12 */public static <T, R1, R2, R>Collector<T, ?, R> teeing(Collector<? super T, ?, R1> downstream1,                          Collector<? super T, ?, R2> downstream2,                          BiFunction<? super R1, ? super R2, R> merger) {    return teeing0(downstream1, downstream2, merger);}

@FunctionalInterfacepublic interface BiFunction<T, U, R> {
    /**     * Applies this function to the given arguments.     *     * @param t the first function argument     * @param u the second function argument     * @return the function result     */    R apply(T t, U u);}

class CountSum {    private final Long count;    private final Integer sum;    public CountSum(Long count, Integer sum) {        this.count = count;        this.sum = sum;    }
    @Override    public String toString() {        return "CountSum{" +                "count=" + count +                ", sum=" + sum +                '}';    }}

CountSum countsum = Stream.of(2, 11, 1, 5, 7, 8, 12)        .collect(Collectors.teeing(                counting(),                summingInt(e -> e),                CountSum::new));
System.out.println(countsum.toString());

class MinMax {    private final Integer min;    private final Integer max;    public MinMax(Integer min, Integer max) {        this.min = min;        this.max = max;    }
    @Override    public String toString() {        return "MinMax{" +                "min=" + min +                ", max=" + max +                '}';    }}

MinMax minmax = Stream.of(2, 11, 1, 5, 7, 8, 12)        .collect(Collectors.teeing(                minBy(Comparator.naturalOrder()),                maxBy(Comparator.naturalOrder()),                (Optional<Integer> a, Optional<Integer> b) -> new MinMax(a.orElse(Integer.MIN_VALUE), b.orElse(Integer.MAX_VALUE))));
System.out.println(minmax.toString());

MinMax minmax = Stream.of(null, 2, 11, 1, 5, 7, 8, 12)                .collect(Collectors.teeing(                        minBy(Comparator.nullsFirst(Comparator.naturalOrder())),                        maxBy(Comparator.nullsLast(Comparator.naturalOrder())),                        (Optional<Integer> a, Optional<Integer> b) -> new MinMax(a.orElse(Integer.MIN_VALUE), b.orElse(Integer.MAX_VALUE))));

// 定义瓜的类型和重量class Melon {    private final String type;    private final int weight;    public Melon(String type, int weight) {        this.type = type;        this.weight = weight;    }
    public String getType() {        return type;    }
    public int getWeight() {        return weight;    }}
// 总重和单个重量列表class WeightsAndTotal {    private final int totalWeight;    private final List<Integer> weights;    public WeightsAndTotal(int totalWeight, List<Integer> weights) {        this.totalWeight = totalWeight;        this.weights = weights;    }
    @Override    public String toString() {        return "WeightsAndTotal{" +                "totalWeight=" + totalWeight +                ", weights=" + weights +                '}';    }}

List<Melon> melons = Arrays.asList(new Melon("Crenshaw", 1200),    new Melon("Gac", 3000), new Melon("Hemi", 2600),    new Melon("Hemi", 1600), new Melon("Gac", 1200),    new Melon("Apollo", 2600), new Melon("Horned", 1700),    new Melon("Gac", 3000), new Melon("Hemi", 2600));

WeightsAndTotal weightsAndTotal = melons.stream()    .collect(Collectors.teeing(            summingInt(Melon::getWeight),            mapping(m -> m.getWeight(), toList()),            WeightsAndTotal::new));
System.out.println(weightsAndTotal.toString());

class Guest {    private String name;    private boolean participating;    private Integer participantsNumber;
    public Guest(String name, boolean participating, Integer participantsNumber) {        this.name = name;        this.participating = participating;        this.participantsNumber = participantsNumber;    }    public boolean isParticipating() {        return participating;    }
    public Integer getParticipantsNumber() {        return participantsNumber;    }
    public String getName() {        return name;    }}
class EventParticipation {    private List<String> guestNameList;    private Integer totalNumberOfParticipants;
    public EventParticipation(List<String> guestNameList, Integer totalNumberOfParticipants) {        this.guestNameList = guestNameList;        this.totalNumberOfParticipants = totalNumberOfParticipants;    }
    @Override    public String toString() {        return "EventParticipation { " +                "guests = " + guestNameList +                ", total number of participants = " + totalNumberOfParticipants +                " }";    }}

var result = Stream.of(                new Guest("Marco", true, 3),                new Guest("David", false, 2),                new Guest("Roger",true, 6))                .collect(Collectors.teeing(                        Collectors.filtering(Guest::isParticipating, Collectors.mapping(Guest::getName, Collectors.toList())),                        Collectors.summingInt(Guest::getParticipantsNumber),                        EventParticipation::new                ));System.out.println(result);