/** * 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. * * 
The resulting collector functions do the following: * * 
         
           * 
          
supplier: creates a result container that contains result containers * obtained by calling each collector's supplier * 
          
accumulator: calls each collector's accumulator with its result container * and the input element * 
          
combiner: calls each collector's combiner with two result containers * 
          
finisher: calls each collector's finisher with its result container, * then calls the supplied merger and returns its result. * 
         
 * * 
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 
          
                    the type of the input elements * @param 
           
                    the result type of the first collector * @param 
            
                     the result type of the second collector * @param 
             
                       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 
              
               Collector
               
                 teeing(Collector
                 downstream1, Collector
                 downstream2, BiFunction
                 merger) { return teeing0(downstream1, downstream2, merger);}
               
              
             
            
           
          

@FunctionalInterfacepublic interface BiFunction
         
           {     /**     * 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
         
           a, Optional
          
            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
         
           a, Optional
          
            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
         
           weights;    public WeightsAndTotal(int totalWeight, List
          
            weights) {        this.totalWeight = totalWeight;        this.weights = weights;    }     @Override    public String toString() {        return "WeightsAndTotal{" +                "totalWeight=" + totalWeight +                ", weights=" + weights +                '}';    }}
          
         

List
         
           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
         
           guestNameList;    private Integer totalNumberOfParticipants;     public EventParticipation(List
          
            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);