JAVA8-Collector interface源码分析 Collector interface源码分析源码public interface Collector<T, A, R> { Supplier<A> supplier(); BiConsumer<A, T> accumulator(); Function<A, R> finisher(); BinaryOperator<A> combiner(); Set<Characteristics> characteristics(); }说明：1.T is the generic type of the items in the stream to be collected.2.A is the type of the accumulator, the object on which the partial result will be accumulated during thecollection process.3.R is the type of the object (typically, but not always, the collection) resulting from the collectoperation.T:传入参数类型，A：需要进行处理的方法，R：处理后返回的结果特征值：CONCURRENT：并行的UNORDERED：无序的IDENTITY_FINISH：传入什么，返回什么范例toList()源码1、入口menu.stream().filter(t->t.isVegetarian()).collect(Collectors.toList())2、Collectors.toList()源码： public static <T> Collector<T, ?, List<T>> toList() { return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add, (left, right) -> { left.addAll(right); return left; }, CH_ID); }3、最后也就是Collector接口 CollectorImpl(Supplier<A> supplier, BiConsumer<A, T> accumulator, BinaryOperator<A> combiner, Set<Characteristics> characteristics) { this(supplier, accumulator, combiner, castingIdentity(), characteristics); }流程图1、Collector执行流程图 执行过程:通过Supplier supplier创建一个Container容器。查看stream里面是否还有元素。如果有，通过带2个入参一个返回结果参数的BiConsumer<A, T> accumulator进行数据处理。处理完后通过finisher返回执行结果。collect源码： 说明：1、获取容器container = collector.supplier().get(); 2、通过accumulator进行处理forEach(u -> accumulator.accept(container, u));3、执行完，返回执行结果return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)2、combiner并行执行执行流程图 产生多个supplier并行处理，然后将多个处理结果combiner成一个，然后将结果返回。

JAVA8-Collectors API:summingDouble、summingInt、testSummingLong、toCollection、toConcurrentMap、toList、toSet、toMap JAVA8-Collectors API:summingDouble、summingInt、testSummingLong、toCollection、toConcurrentMap、toList、toSet、toMap前置数据 public static final List<Dish> menu = Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT), new Dish("beef", false, 700, Dish.Type.MEAT), new Dish("chicken", false, 400, Dish.Type.MEAT), new Dish("french fries", true, 530, Dish.Type.OTHER), new Dish("rice", true, 350, Dish.Type.OTHER), new Dish("season fruit", true, 120, Dish.Type.OTHER), new Dish("pizza", true, 550, Dish.Type.OTHER), new Dish("prawns", false, 300, Dish.Type.FISH), new Dish("salmon", false, 450, Dish.Type.FISH));范例：1、summingDouble public static void testAveragingDouble(){ System.out.println("testAveragingDouble"); //用reduce聚合求和 Optional.ofNullable(menu.stream().map(Dish::getCalories).reduce(Integer::sum)).get().ifPresent(System.out::println); //用collectors averagingDouble求平均值 Optional.ofNullable(menu.stream().collect(averagingDouble(Dish::getCalories))).ifPresent(System.out::println); }输出结果：testSummingDouble 4200.0 42002、summingDouble public static void testSummingInt() { System.out.println("testSummingInt"); Optional.ofNullable(menu.stream().collect(Collectors.summingInt(Dish::getCalories))).ifPresent(System.out::println); }输出结果：testSummingInt 42003、summingLong public static void testSummingLong() { System.out.println("testSummingLong"); Optional.ofNullable(menu.stream().collect(Collectors.summingLong(Dish::getCalories))).ifPresent(System.out::println); }输出结果：testSummingLong 42004、toCollection 返回Collection子类 public static void testToCollection() { System.out.println("testToCollection"); Optional.ofNullable(menu.stream().collect(Collectors.toCollection(LinkedList::new))).ifPresent(System.out::println); }输出结果：testToCollection [Dish{name='pork', vegetarian=false, calories=800, type=MEAT}, Dish{name='beef', vegetarian=false, calories=700, type=MEAT}, Dish{name='chicken', vegetarian=false, calories=400, type=MEAT}, Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='rice', vegetarian=true, calories=350, type=OTHER}, Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='pizza', vegetarian=true, calories=550, type=OTHER}, Dish{name='prawns', vegetarian=false, calories=300, type=FISH}, Dish{name='salmon', vegetarian=false, calories=450, type=FISH}]5、toConcurrentMap public static void testToConcurrentMap() { System.out.println("testToConcurrentMap"); Optional.ofNullable(menu.stream().collect(Collectors.toConcurrentMap(Dish::getName,Dish::getCalories))).ifPresent(System.out::println); }输出结果：testToConcurrentMap {season fruit=120, chicken=400, pizza=550, salmon=450, beef=700, pork=800, rice=350, french fries=530, prawns=300}6、toConcurrentMap 按类型统计个数 public static void testToConcurrentMapWithBinaryOperator() { System.out.println("testToConcurrentMapWithBinaryOperator"); Optional.ofNullable(menu.stream().collect(Collectors.toConcurrentMap(Dish::getType,v->1L,(a,b)->a+b))).ifPresent(v->{ System.out.println(v); System.out.println(v.getClass()); }); }输出结果：testToConcurrentMapWithBinaryOperator {OTHER=4, MEAT=3, FISH=2} class java.util.concurrent.ConcurrentHashMap7、toConcurrentMap 按类型统计个数，返回指定类型Map public static void testToConcurrentMapWithBinaryOperatorAndSupplier() { System.out.println("testToConcurrentMapWithBinaryOperatorAndSupplier"); Optional.ofNullable(menu.stream().collect(Collectors.toConcurrentMap(Dish::getType,v->1L,(a,b)->a+b, ConcurrentSkipListMap::new))).ifPresent(v->{ System.out.println(v); System.out.println(v.getClass()); }); }输出结果：testToConcurrentMapWithBinaryOperatorAndSupplier {MEAT=3, FISH=2, OTHER=4} class java.util.concurrent.ConcurrentSkipListMap8、toList 转成list public static void testTolist() { System.out.println("testTolist"); Optional.ofNullable(menu.stream().filter(t->t.isVegetarian()).collect(Collectors.toList())).ifPresent(v->{ System.out.println(v); System.out.println(v.getClass()); }); }输出结果：testTolist [Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='rice', vegetarian=true, calories=350, type=OTHER}, Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='pizza', vegetarian=true, calories=550, type=OTHER}] class java.util.ArrayList9、toSett 转成Set public static void testToSet() { System.out.println("testToSet"); Optional.ofNullable(menu.stream().filter(t->t.isVegetarian()).collect(Collectors.toSet())).ifPresent(v->{ System.out.println(v); System.out.println(v.getClass()); }); }输出结果：testToSet [Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='pizza', vegetarian=true, calories=550, type=OTHER}, Dish{name='rice', vegetarian=true, calories=350, type=OTHER}] class java.util.HashSet10、toMappublic static void testToMap() { System.out.println("testToMap"); Optional.ofNullable(menu.stream().collect(Collectors.toMap(Dish::getName,Dish::getCalories))).ifPresent(v->{ System.out.println(v); System.out.println(v.getClass()); }); //转成线程安全的map Optional.ofNullable(menu.stream().collect(Collectors.collectingAndThen(Collectors.toMap(Dish::getName, Dish::getCalories), Collections::synchronizedMap))).ifPresent(v->{ System.out.println(v); System.out.println(v.getClass()); }); }输出结果：testToMap {season fruit=120, chicken=400, pizza=550, salmon=450, beef=700, pork=800, rice=350, french fries=530, prawns=300} class java.util.HashMap {season fruit=120, chicken=400, pizza=550, salmon=450, beef=700, pork=800, rice=350, french fries=530, prawns=300} class java.util.Collections$SynchronizedMap11、toMap 按类型统计个数public static void testToMapWithBinaryOperator() { System.out.println("testToMapWithBinaryOperator"); Optional.ofNullable(menu.stream().collect(Collectors.toMap(Dish::getType,v->1L,(a,b)->a+b))).ifPresent(v->{ System.out.println(v); System.out.println(v.getClass()); }); }输出结果：testToMapWithBinaryOperator {MEAT=3, FISH=2, OTHER=4} class java.util.HashMap12、toMap 按类型统计个数，返回指定类型Ma ##p public static void testToMapWithBinaryOperatorAndSupplier() { System.out.println("testToMapWithBinaryOperatorAndSupplier"); Optional.ofNullable(menu.stream().collect(Collectors.toMap(Dish::getType,v->1L,(a,b)->a+b, ConcurrentSkipListMap::new))).ifPresent(v->{ System.out.println(v); System.out.println(v.getClass()); }); }输出结果：testToMapWithBinaryOperatorAndSupplier {MEAT=3, FISH=2, OTHER=4} class java.util.concurrent.ConcurrentSkipListMap

JAVA8-Collectors API: partitioningBy、reducing、summarizingLong、summarizingInt、summarizingDouble JAVA8-Collectors API: partitioningBy、reducing、summarizingLong、summarizingInt、summarizingDouble前置数据： public static final List<Dish> menu = Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT), new Dish("beef", false, 700, Dish.Type.MEAT), new Dish("chicken", false, 400, Dish.Type.MEAT), new Dish("french fries", true, 530, Dish.Type.OTHER), new Dish("rice", true, 350, Dish.Type.OTHER), new Dish("season fruit", true, 120, Dish.Type.OTHER), new Dish("pizza", true, 550, Dish.Type.OTHER), new Dish("prawns", false, 300, Dish.Type.FISH), new Dish("salmon", false, 450, Dish.Type.FISH));范例：1、partitioningBy 分组 public static void testPartitioningByWithPredicate() { System.out.println("testPartitioningByWithPredicate"); Map<Boolean, List<Dish>> collect = menu.stream().collect(Collectors.partitioningBy(Dish::isVegetarian)); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testPartitioningByWithPredicate {false=[Dish{name='pork', vegetarian=false, calories=800, type=MEAT}, Dish{name='beef', vegetarian=false, calories=700, type=MEAT}, Dish{name='chicken', vegetarian=false, calories=400, type=MEAT}, Dish{name='prawns', vegetarian=false, calories=300, type=FISH}, Dish{name='salmon', vegetarian=false, calories=450, type=FISH}], true=[Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='rice', vegetarian=true, calories=350, type=OTHER}, Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='pizza', vegetarian=true, calories=550, type=OTHER}]}2、partitioningBy 分组后，再处理求平均数 public static void testPartitioningByWithPredicateAndCollecotr() { System.out.println("testPartitioningByWithPredicateAndCollecotr"); Map<Boolean, Double> collect = menu.stream().collect(Collectors.partitioningBy(Dish::isVegetarian, Collectors.averagingInt(Dish::getCalories))); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testPartitioningByWithPredicateAndCollecotr {false=530.0, true=387.5}3、reducing public static void testReducingBinaryOperator() { System.out.println("testReducingBinaryOperator"); Optional<Dish> collect = menu.stream().collect(Collectors.reducing(BinaryOperator.maxBy(Comparator.comparingInt(Dish::getCalories)))); collect.ifPresent(System.out::println); }输出结果：testReducingBinaryOperator Dish{name='pork', vegetarian=false, calories=800, type=MEAT}4、reducing public static void testReducingBinaryOperatorAndIdentity() { System.out.println("testReducingBinaryOperatorAndIdentity"); Integer collect = menu.stream().map(Dish::getCalories).collect(Collectors.reducing(0, (d1, d2) -> d1 + d2)); System.out.println(collect); }输出结果：testReducingBinaryOperatorAndIdentity 42005、reducing public static void testReducingBinaryOperatorAndIdentityAndFunction() { System.out.println("testReducingBinaryOperatorAndIdentityAndFunction"); Integer collect = menu.stream().collect(Collectors.reducing(0, Dish::getCalories,(d1, d2) -> d1 + d2)); System.out.println(collect); }输出结果：testReducingBinaryOperatorAndIdentityAndFunction 42006、summarizingDouble public static void testSummarizingDouble() { System.out.println("testSummarizingDouble"); DoubleSummaryStatistics collect = menu.stream().collect(Collectors.summarizingDouble(Dish::getCalories)); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testSummarizingDouble DoubleSummaryStatistics{count=9, sum=4200.000000, min=120.000000, average=466.666667, max=800.000000}7、summarizingInt public static void testSummarizingInt() { System.out.println("testSummarizingDouble"); IntSummaryStatistics collect = menu.stream().collect(Collectors.summarizingInt(Dish::getCalories)); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testSummarizingDouble IntSummaryStatistics{count=9, sum=4200, min=120, average=466.666667, max=800}8、summarizingLong public static void testSummarizingLong() { System.out.println("testSummarizingLong"); LongSummaryStatistics collect = menu.stream().collect(Collectors.summarizingLong(Dish::getCalories)); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testSummarizingLong LongSummaryStatistics{count=9, sum=4200, min=120, average=466.666667, max=800}

JAVA8-Collectors API: groupingByConcurrent、joining、mapping、maxby、minby JAVA8-Collectors API: groupingByConcurrent、joining、mapping、maxby、minby前置数据 public static final List<Dish> menu = Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT), new Dish("beef", false, 700, Dish.Type.MEAT), new Dish("chicken", false, 400, Dish.Type.MEAT), new Dish("french fries", true, 530, Dish.Type.OTHER), new Dish("rice", true, 350, Dish.Type.OTHER), new Dish("season fruit", true, 120, Dish.Type.OTHER), new Dish("pizza", true, 550, Dish.Type.OTHER), new Dish("prawns", false, 300, Dish.Type.FISH), new Dish("salmon", false, 450, Dish.Type.FISH));范例：1、groupingByConcurrent 返回map为ConcurrentMap,按类型分组 public static void testGroupingByConcurrentWithFunction() { System.out.println("testGroupingByConcurrentWithFunction"); ConcurrentMap<Dish.Type, List<Dish>> collect = menu.stream().collect(Collectors.groupingByConcurrent(Dish::getType)); Optional.ofNullable(collect.getClass()).ifPresent(System.out::println); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testGroupingByConcurrentWithFunction class java.util.concurrent.ConcurrentHashMap {MEAT=[Dish{name='pork', vegetarian=false, calories=800, type=MEAT}, Dish{name='beef', vegetarian=false, calories=700, type=MEAT}, Dish{name='chicken', vegetarian=false, calories=400, type=MEAT}], FISH=[Dish{name='prawns', vegetarian=false, calories=300, type=FISH}, Dish{name='salmon', vegetarian=false, calories=450, type=FISH}], OTHER=[Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='rice', vegetarian=true, calories=350, type=OTHER}, Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='pizza', vegetarian=true, calories=550, type=OTHER}]}2、groupingByConcurrent 返回map为ConcurrentMap,按按类型分组，并求平均值 public static void testGroupingByConcurrentWithFunctionAndCollector() { System.out.println("testGroupingByConcurrentWithFunctionAndCollector"); Map<Dish.Type, Double> collect = menu.stream().collect(Collectors.groupingByConcurrent(Dish::getType, Collectors.averagingInt(Dish::getCalories))); Optional.ofNullable(collect.getClass()).ifPresent(System.out::println); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testGroupingByConcurrentWithFunctionAndCollector class java.util.concurrent.ConcurrentHashMap {MEAT=633.3333333333334, FISH=375.0, OTHER=387.5}3、groupingByConcurrent 返回map为ConcurrentMap,按按类型分组，并求平均值,并修改返回类型为ConcurrentSkipListMap(跳表，以空间换时间的数据结构) public static void testGroupingByConcurrentWithFunctionAndSupplierAndCollector() { System.out.println("testGroupingByConcurrentWithFunctionAndSupplierAndCollector"); ConcurrentSkipListMap<Dish.Type, Double> collect = menu.stream().collect(Collectors.groupingByConcurrent(Dish::getType, ConcurrentSkipListMap::new, Collectors.averagingInt(Dish::getCalories))); Optional.ofNullable(collect.getClass()).ifPresent(System.out::println); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testGroupingByConcurrentWithFunctionAndSupplierAndCollector class java.util.concurrent.ConcurrentSkipListMap {MEAT=633.3333333333334, FISH=375.0, OTHER=387.5}4、joining 拼接，不能直接join public static void testJoin() { System.out.println("testJoin"); String collect = menu.stream().map(Dish::getName).collect(Collectors.joining()); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testJoin porkbeefchickenfrench friesriceseason fruitpizzaprawnssalmon5、joining 拼接,通过逗号拼接 public static void testJoinWithDelimiter() { System.out.println("testJoinWithDelimter"); String collect = menu.stream().map(Dish::getName).collect(Collectors.joining(",")); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testJoinWithDelimter pork,beef,chicken,french fries,rice,season fruit,pizza,prawns,salmon6、joining 拼接,通过逗号拼接,拼接后加前缀和后缀 public static void testJoinWithDelimiterAndPrefixAndSuffix() { System.out.println("testJoinWithDelimiterAndPrefixAndSuffix"); String collect = menu.stream().map(Dish::getName).collect(Collectors.joining(",","Names:[","]")); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testJoinWithDelimiterAndPrefixAndSuffix Names:[pork,beef,chicken,french fries,rice,season fruit,pizza,prawns,salmon]7、mapping 拼接，能直接join public static void testMapping() { System.out.println("testMapping"); String collect = menu.stream().collect(Collectors.mapping(Dish::getName, Collectors.joining(","))); Optional.ofNullable(collect).ifPresent(System.out::println); }输出结果：testMapping pork,beef,chicken,french fries,rice,season fruit,pizza,prawns,salmon8、maxBy 查找最大的一个Dish public static void testMaxBy() { System.out.println("testMaxBy"); Optional<Dish> collect = menu.stream().collect(Collectors.maxBy(Comparator.comparing(Dish::getCalories))); collect.ifPresent(System.out::println); }输出结果：testMaxBy Dish{name='pork', vegetarian=false, calories=800, type=MEAT}9、minBy 查找最小的一个Dish public static void testMinBy() { System.out.println("testMinBy"); Optional<Dish> collect = menu.stream().collect(Collectors.minBy(Comparator.comparing(Dish::getCalories))); collect.ifPresent(System.out::println); }输出结果：testMinBy Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}

JAVA8-Collectors API:averaging、collectingAndThen、counting、groupingBy JAVA8-Collectors API:averaging、collectingAndThen、counting、groupingBy前置数据 public static final List<Dish> menu = Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT), new Dish("beef", false, 700, Dish.Type.MEAT), new Dish("chicken", false, 400, Dish.Type.MEAT), new Dish("french fries", true, 530, Dish.Type.OTHER), new Dish("rice", true, 350, Dish.Type.OTHER), new Dish("season fruit", true, 120, Dish.Type.OTHER), new Dish("pizza", true, 550, Dish.Type.OTHER), new Dish("prawns", false, 300, Dish.Type.FISH), new Dish("salmon", false, 450, Dish.Type.FISH));范例：1、averagingDouble 求平均值 public static void testAveragingDouble(){ System.out.println("testAveragingDouble"); //用reduce聚合求和 Optional.ofNullable(menu.stream().map(Dish::getCalories).reduce(Integer::sum)).get().ifPresent(System.out::println); //用collectors averagingDouble求平均值 Optional.ofNullable(menu.stream().collect(averagingDouble(Dish::getCalories))).ifPresent(System.out::println); }输出结果：testAveragingDouble 4200 466.66666666666672、averagingInt 求平均值 public static void testAveragingInt(){ System.out.println("testAveragingInt"); //用collectors averagingDouble求平均值 Optional.ofNullable(menu.stream().collect(averagingInt(Dish::getCalories))).ifPresent(System.out::println); }输出结果：testAveragingInt 466.66666666666673、averagingLong 求平均值 public static void testAveragingLong(){ System.out.println("testAveragingLong"); //用collectors averagingLong求平均值 Optional.ofNullable(menu.stream().collect(averagingLong(Dish::getCalories))).ifPresent(System.out::println); }输出结果：testAveragingLong 466.66666666666674、collectingAndThen(收集数据，处理数据)，将搜集结果，再做处理。4.1、CollectingAndThen 求平均数后，拼接一句话 Optional.ofNullable(menu.stream().collect(Collectors.collectingAndThen(averagingInt(Dish::getCalories),a->"This is Calories eques = "+a))).ifPresent(System.out::println);输出结果：testCollectingAndThen This is Calories eques = 466.66666666666674.2、获取MEAT类，之后再往里面加入其它类型 List<Dish> collect = menu.stream().filter(m -> Dish.Type.MEAT.equals(m.getType())).collect(toList()); collect.add(new Dish("回锅肉", true, 550, Dish.Type.OTHER)); collect.stream().forEach(System.out::println);输出结果：Dish{name='pork', vegetarian=false, calories=800, type=MEAT} Dish{name='beef', vegetarian=false, calories=700, type=MEAT} Dish{name='chicken', vegetarian=false, calories=400, type=MEAT} Dish{name='回锅肉', vegetarian=true, calories=550, type=OTHER}4.3、CollectingAndThen 如果想将收集结果设置为不可修改 List<Dish> meatCollect = menu.stream().filter(m -> Dish.Type.MEAT.equals(m.getType())).collect(collectingAndThen(toList(), Collections::unmodifiableList)); //修改时就会报错：Exception in thread "main" java.lang.UnsupportedOperationException meatCollect.add(new Dish("回锅肉", true, 550, Dish.Type.OTHER)); collect.stream().forEach(System.out::println);输出结果：Exception in thread "main" java.lang.UnsupportedOperationException5、counting 统计 返回Long类型 public static void testCounting(){ System.out.println("testCounting"); Optional.ofNullable(menu.stream().collect(Collectors.counting())).ifPresent(System.out::println); }输出结果：testCounting 96、groupingBy 分组public static void testGroupingByFunction(){ System.out.println("testGroupingByFunction"); Optional.of(menu.stream().collect(Collectors.groupingBy(Dish::getType))).ifPresent(System.out::println); }输出结果：testGroupingByFunction {OTHER=[Dish{name='french fries', vegetarian=true, calories=530, type=OTHER}, Dish{name='rice', vegetarian=true, calories=350, type=OTHER}, Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='pizza', vegetarian=true, calories=550, type=OTHER}], MEAT=[Dish{name='pork', vegetarian=false, calories=800, type=MEAT}, Dish{name='beef', vegetarian=false, calories=700, type=MEAT}, Dish{name='chicken', vegetarian=false, calories=400, type=MEAT}], FISH=[Dish{name='prawns', vegetarian=false, calories=300, type=FISH}, Dish{name='salmon', vegetarian=false, calories=450, type=FISH}]} 7、groupingBy 分组后统计 public static void testGroupingByFunctionAndCollector(){ System.out.println("testGroupingByFunctionAndCollector"); Optional.of(menu.stream().collect(Collectors.groupingBy(Dish::getType,counting()))).ifPresent(System.out::println); }输出结果：testGroupingByFunctionAndCollector {OTHER=4, MEAT=3, FISH=2}8、groupingBy 分组后求平均值，默认是HashMap,通过groupingBy修改返回类型 public static void testGroupingByFunctionAndSuppilerAndCollector(){ System.out.println("testGroupingByFunctionAndSuppilerAndCollector"); Map<Dish.Type, Double> map = Optional.of(menu.stream().collect(groupingBy(Dish::getType, averagingInt(Dish::getCalories)))).get(); //默认是返回HashMap类型 Optional.ofNullable(map.getClass()).ifPresent(System.out::println); TreeMap<Dish.Type, Double> newMap = Optional.of(menu.stream().collect(groupingBy(Dish::getType, TreeMap::new, averagingInt(Dish::getCalories)))).get(); //groupingBy:修改返回类型为TreeMap Optional.ofNullable(newMap.getClass()).ifPresent(System.out::println); }输出结果：testGroupingByFunctionAndSuppilerAndCollector class java.util.HashMap class java.util.TreeMap

JAVA8-Optional API Optional API一、Optional创建方式前置条件：Insurance对象：public class Insurance { private String name; public String getName() { return name; } }1、empty特点：使用get()方法时会抛出异常：No value present范例：Optional<Insurance> emptyOptional = Optional.<Insurance>empty();使用get（）获取结果：抛出异常emptyOptional.get();输出结果:Exception in thread "main" java.util.NoSuchElementException: No value present at java.base/java.util.Optional.get(Optional.java:148)2、of特点：使用get（）,不会抛异常范例：Optional<Insurance> ofInsurance = Optional.of(new Insurance()); ofInsurance.get();3、ofNullable特点：上面两者综合，为null是掉empty，不为空调of。3.1、为null时，调get()抛出异常范例： Optional<Insurance> ofNullableOptionalNull = Optional.ofNullable(null); ofNullableOptionalNull.get();输出结果：Exception in thread "main" java.util.NoSuchElementException: No value present3.2、不为null时，调get()不报错范例： Optional<Insurance> ofNullableOptionalNotNull = Optional.ofNullable(new Insurance()); ofNullableOptionalNotNull.get();二、orElseGet、orElse、orElseThrow不管那种方式创建，都适用这几个方法。1、orElseGet说明：不为null就返回值，为null返回一个构造的对象supplier范例：Insurance orElseGetInsurance = ofNullableOptionalNull.orElseGet(Insurance::new); System.out.println(orElseGetInsurance);2、orElse说明：不为null就返回值，否则返回一个引用范例：Insurance orElseInsurance = ofNullableOptionalNull.orElse(new Insurance()); System.out.println(orElseInsurance);3、orElseThrow说明：不为null就返回值，否则返回一个异常对象范例：Insurance orElseThrowInsurance = ofNullableOptionalNull.orElseThrow(RuntimeException::new);输出结果：抛出运行时异常Exception in thread "main" java.lang.RuntimeException at java.base/java.util.Optional.orElseThrow(Optional.java:408)4、orElseThrow说明：不为null就返回值，否则返回一个自定义异常对象范例：ofNullableOptionalNull.orElseThrow(() -> new RuntimeException("yanxizhu Exception"));输出结果：抛出自定义异常Exception in thread "main" java.lang.RuntimeException: yanxizhu Exception三、filter先判断传入predicate是否null，让然后判断predicate传入字段是否存在，不存在：返回this。存在：判断predicate条件是否成立，成立：返回this，不成立：返回空。源码: public Optional<T> filter(Predicate<? super T> predicate) { //1、判断传入参数predicate是否为null Objects.requireNonNull(predicate); //2、判断t.getName是否存在， if (!isPresent()) { //2.1、不存在，返回predicate return this; } else { //2.2、存在：判断predicate条件是否成立，成立返回this，不成立返回empty() return predicate.test(value) ? this : empty(); } }requireNonNull()源码：判断传入T是否为null public static <T> T requireNonNull(T obj) { if (obj == null) throw new NullPointerException(); return obj; }范例：使用前创建Optional对象：1、创建Optinal，get()会抛出异常 Optional<Insurance> emptyOptional = Optional.<Insurance>empty(); 2、of创建，get（）,不会抛异常 Optional<Insurance> ofInsurance = Optional.of(new Insurance()); 3、ofNullable：上面两者综合 3.1、为null时，调get()抛出异常：No value present Optional<Insurance> ofNullableOptionalNull = Optional.ofNullable(null); 3.2、不为null时，调get()不报错 Optional<Insurance> ofNullableOptionalNotNull = Optional.ofNullable(new Insurance());使用demo1： Optional<Insurance> insurance = emptyOptional.filter(t -> t.getName() == null); Optional<Insurance> insurance = emptyOptional.filter(t -> t.getName() != null); insurance.get();结果：//调用get（）,都会报错：No value present: 因为name字段不存在使用demo2：范例1：Optional<Insurance> insurance = ofInsurance.filter(t -> t.getName() == null); insurance.get(); 结果：//不报错，因为name字段存在，且满足name==null范例2：Optional<Insurance> insurance = ofInsurance.filter(t -> t.getName() != null); insurance.get(); 结果：//报错，因为name虽然存在，但是name!=null,不成立，会返回empty空，使用get()时就会抛出异常：No value present使用demo3： Optional<Insurance> insurance = ofNullableOptionalNull.filter(t -> t.getName() != null); Optional<Insurance> insurance = ofNullableOptionalNull.filter(t -> t.getName() == null); insurance.get();结果：//都报错：ofNullableOptional,会走empty创建的Optional，字段不存在，直接get获取值为空，报错：No value present使用demo4：范例1：Optional<Insurance> insurance = ofNullableOptionalNotNull.filter(t -> t.getName() == null); insurance.get(); 结果：//不会报错,走of方法创建的Optional，name字段存在，且name==null，所以不报错范例2：Optional<Insurance> insurance = ofNullableOptionalNotNull.filter(t -> t.getName() != null); insurance.get(); 结果：//报错，因为虽然name存在，但是name!=null不成立，返回empty，get(）就报错了filter，总结：使用时不确定是否为empty，所以直接使用ofNullableOptional创建Optional.四、map使用任何方式创建的Opional,map会将结果再包装成Optionla。范例： //map使用 Optional<String> stringOptional = ofNullableOptionalNotNull.map(t -> t.getName()); //有值则返回，没值则返回给定值 System.out.println(stringOptional.orElse("-1")); //判断值是否存在 System.out.println(stringOptional.isPresent()); //存在值，则打印输出，没有值，不打印。 stringOptional.ifPresent(System.out::println);五、flatMap不会将结果再包装成Optional范例：前置条件 @Data public class Cat { private Optional<Eat> eat; } @Data public class Eat { private String foodName; private Integer weight; }使用： //创建Optional对象 Optional<Cat> cat = Optional.ofNullable(new Cat()); //map将结果包装成Optional Optional<Optional<Eat>> eat = cat.map(c -> c.getEat()); //flatMap不会 Optional<Eat> eat1 = cat.flatMap(c -> c.getEat());map与flatMap区别：map将结果包装成Optional，flatMap不会。六、实列实列1、获取值之前判断值是否为空 public static String getInsuranceName(Insurance insurance) { Optional<String> optional = Optional.ofNullable(insurance).map(Insurance::getName); return optional.orElse("-1"); }实列2、根据用户拿到保险名字package com.example.study.java8.optional; import java.util.Optional; /** * 根据用户拿到保险名字 */ public class NullPointerException { public static void main(String[] args) { //肯定会包空指针异常 // String insuranceNameByPerson = getInsuranceNameByPerson(new Person()); //原始写法,做了空指针判断 String insuranceNameByCheckPerson = getInsuranceNameByCheckPerson(new Person()); // System.out.println(insuranceNameByCheckPerson); //Opional写法 String insuranceNameByOptional = getInsuranceNameByOptional(null); System.out.println(insuranceNameByOptional); } //Opional写法 public static String getInsuranceNameByOptional(Person person) { return Optional.ofNullable(person) .map(Person::getCar) .map(Car::getInsurance) .map(Insurance::getName) .orElse("-1"); } //flatMap不会把结果包装成Optional，map会。 //原始写法判断 public static String getInsuranceNameByCheckPerson(Person person) { if(null != person) { if(null != person.getCar()) { Car car = person.getCar(); if (null != car) { Insurance insurance = car.getInsurance(); if (null != insurance) { return insurance.getName(); } } } } return "UNKNOWN"; } public static String getInsuranceNameByPerson(Person person){ return person.getCar().getInsurance().getName(); } }

JAVA8-Stram练手 JAVA8-Stram练手交易员对象：package com.example.study.java8.streams.demo; /** * 交易员 */ public class Trader { private final String name; private final String city; public Trader(String n, String c){ this.name = n; this.city = c; } public String getName(){ return this.name; } public String getCity(){ return this.city; } public String toString(){ return "Trader:"+this.name + " in " + this.city; } } 交易对象package com.example.study.java8.streams.demo; /** * 交易 */ public class Transaction { private final Trader trader; private final int year; private final int value; public Transaction(Trader trader, int year, int value){ this.trader = trader; this.year = year; this.value = value; } public Trader getTrader(){ return this.trader; } public int getYear(){ return this.year; } public int getValue(){ return this.value; } public String toString(){ return "{" + this.trader + ", " + "year: "+this.year+", " + "value:" + this.value +"}"; } } 需求说明：1、交易年未2011年，并按交易金额排序2、获取城市并去重3、获取交易员所在城市为“Cambridge”的交易员，去重，并按交易员名字排序4、获取所有交易员名字，并排序,拼接成字符串5、交易员城市是否有在Milan的6、打印所有交易值，且交易员所在城市是Milan的7、找最大的值8、找最小的值需求实现范例：package com.example.study.java8.streams.demo; import java.util.Arrays; import java.util.Comparator; import java.util.List; import java.util.Optional; import static java.util.stream.Collectors.toList; /** * 交易员进行交易 */ public class StreamInAction { public static void main(String[] args) { Trader raoul = new Trader("Raoul", "Cambridge"); Trader mario = new Trader("Mario", "Milan"); Trader alan = new Trader("Alan", "Cambridge"); Trader brian = new Trader("Brian", "Cambridge"); List<Transaction> transactions = Arrays.asList( new Transaction(brian, 2011, 300), new Transaction(raoul, 2012, 1000), new Transaction(raoul, 2011, 400), new Transaction(mario, 2012, 710), new Transaction(mario, 2012, 700), new Transaction(alan, 2012, 950) ); //1、交易年未2011年，并按交易金额排序 transactions.stream() .filter(t -> t.getYear() == 2011) .sorted(Comparator.comparing(Transaction::getValue)) .collect(toList()) .forEach(System.out::println); System.out.println("==================================="); //2、获取城市并去重 transactions.stream() .map(t -> t.getTrader().getCity()) .distinct() .forEach(System.out::println); System.out.println("==================================="); //3、获取交易员所在城市为“Cambridge”的交易员，去重，并按交易员名字排序 transactions.stream() .map(t->t.getTrader()) .filter(g->"Cambridge".equals(g.getCity())) .distinct() .sorted(Comparator.comparing(Trader::getName)) .forEach(System.out::println); System.out.println("==================================="); //4、获取所有交易员名字，并排序,拼接成字符串 String result = transactions.stream() .map(t -> t.getTrader().getName()) .distinct() .sorted() .reduce("", (str1, str2) -> str1 + "\t" +str2); System.out.println(result); System.out.println("==================================="); //5、交易员城市是否有在Milan的 boolean anyMatch = transactions.stream() .anyMatch(t -> "Milan".equals(t.getTrader().getCity())); System.out.println(anyMatch); //或者 System.out.println("==================================="); boolean anyMatchMap = transactions.stream() .map(t -> t.getTrader()) .anyMatch(n -> "Milan".equals(n.getCity())); System.out.println(anyMatchMap); System.out.println("==================================="); //6、打印所有交易值，且交易员所在城市是Milan的。 transactions.stream() .filter(t->"Cambridge".equals(t.getTrader().getCity())) .map(Transaction::getValue) .sorted() .forEach(System.out::println); //7、找最大的值 System.out.println("==================================="); Optional<Integer> maxValue = transactions.stream() .map(Transaction::getValue) .reduce((i, j) -> i > j ? i : j); System.out.println(maxValue.get()); //8、找最小的值 System.out.println("==================================="); Optional<Integer> minValue = transactions.stream().map(t -> t.getValue()).reduce(Integer::min); System.out.println(minValue.get()); } }

JAVA8-Stream 数值格式 Stream数据类型1、mapToInt、mapToLong、mapToDouble可以将包装类拆箱成基本数据类型，节约内存空间范例：求和方式一：reduce实现 //方式一：reduce实现 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1); list.stream().reduce(Integer::sum).ifPresent(System.out::println); 方式二：mapToInt //方式二：mapToInt list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1); IntStream mapToInt = list.stream().mapToInt(i -> i.intValue()); int sum = mapToInt.sum(); System.out.println(sum);方式三：mapToInt后用reduce实现 //方式三：mapToInt后用reduce实现 list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1); IntStream intStream = list.stream().mapToInt(i -> i.intValue()); int reduce = list.stream().mapToInt(i -> i.intValue()).reduce(0, (i, j) -> i + j); System.out.println(reduce);区别：直接使用reduce实现，使用的是包装类Integer，用mapToInt则可以转成int计算，占用内存更小。2、mapToObj可以将数据直接转成对象，代码量少很多。范例：需求：1--100，中满足勾股定律的数字 3\4\5 9,并返回成一个数组。1、原始分步骤写法： int a = 9; //创建1-100的数字 IntStream rangeClosed = IntStream.rangeClosed(1, 100); //找到满足勾股定律的数字 Stream<Integer> boxed = rangeClosed.filter(i -> Math.sqrt(a * a + i * i) % 1 == 0).boxed(); //将数字转变成int数组返回 Stream<int[]> stream = boxed.map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)}); //输出数组数据 stream.forEach(array->System.out.println("a="+array[0]+",b="+array[1]+",c="+array[2]));2、原始写法，代码简化后 int a = 9; IntStream.rangeClosed(1, 100) .filter(i->Math.sqrt(a*a + i*i)%1==0) .boxed() .map(b->new int[]{a,b,(int)Math.sqrt(a*a+b*b)}) .forEach(array->System.out.println("a="+array[0]+",b="+array[1]+",c="+array[2]));3、mapToObj实现 int a = 9; IntStream.rangeClosed(1, 100) .filter(i->Math.sqrt(a*a + i*i)%1==0) .mapToObj(b->new int[]{a,b,(int)Math.sqrt(a*a+b*b)}) .forEach(array->System.out.println("a="+array[0]+",b="+array[1]+",c="+array[2]));输出结果：a=9,b=12,c=15 a=9,b=40,c=41使用mapToObj，代码更简洁，直接将满足条件数据，转成一个数组对象。

JAVA8-Stream API 二、Stream API：filter、distinct、skip、limit被操作数据List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1);1、filter 过滤范例：//filter 过滤 List<Integer> filterResult = list.stream().filter(i -> i % 2 == 0).collect(toList()); filterResult.stream().forEach(System.out::println);2、distinct 去重范例： //distinct 去重 List<Integer> distinctResult = list.stream().distinct().collect(toList()); distinctResult.stream().forEach(System.out::println);3、skip 截断范例： //skip 截断(跳过前面几个,超过长度，直接返回空) List<Integer> skipResult = list.stream().skip(5).collect(toList()); skipResult.stream().forEach(System.out::println);4、limit 查询几条范例： //limit 查询几条 List<Integer> limitResult = list.stream().limit(3).collect(toList()); limitResult.stream().forEach(System.out::println);二、Stream API：Map1、map 数据处理被操作数据List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1); List<Dish> menu = Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT), new Dish("beef", false, 700, Dish.Type.MEAT), new Dish("chicken", false, 400, Dish.Type.MEAT), new Dish("french fries", true, 530, Dish.Type.OTHER), new Dish("rice", true, 350, Dish.Type.OTHER), new Dish("season fruit", true, 120, Dish.Type.OTHER), new Dish("pizza", true, 550, Dish.Type.OTHER), new Dish("prawns", false, 300, Dish.Type.FISH), new Dish("salmon", false, 450, Dish.Type.FISH)); String[] arrays = {"Hello","world"};范例1： //1、map List<Integer> mapResult = list.stream().map(i -> i * 2).collect(toList()); mapResult.stream().forEach(System.out::println);范例2： //2、map menu.stream().map(Dish::getName).forEach(System.out::println);范例3：//3、flatMap 扁平化 //拆分成String[]: {h,e,l,l,o}，{w,o,r,l,d} Stream<String[]> splitStream = Arrays.stream(arrays).map(s -> s.split("")); //flatMap扁平化，将{h,e,l,l,o}，{w,o,r,l,d}每个数组转成Stream<String> Stream<String> stringStream = splitStream.flatMap(Arrays::stream); stringStream.distinct().forEach(System.out::println);打印结果：H e l o w r d三、Stream API：Match1、Match匹配范例：1.1、allMatch 全部满足条件 Stream<Integer> list = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); //1、allMatch 全部满足条件 boolean booleanAnyMath = list.allMatch(i -> i > 0); System.out.println(booleanAnyMath);1.2、anyMatch 任意一个满足条件 //2、anyMatch 任意一个满足条件 list = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); boolean anyMatch = list.anyMatch(i -> i > 9); System.out.println(anyMatch);1.3、noneMatch 没有一个满足 //3、noneMatch 没有一个满足 list = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); boolean noneMatch = list.noneMatch(i -> i == 11); System.out.println(noneMatch);四、Stream API：find2、find查找范例：2.1、findFirst 查找第一个 //1、findFirst 查找第一个 Optional<Integer> firstOptional = stream.filter(i -> i % 2 == 0).findFirst(); System.out.println(firstOptional); ```` **2.2、findAny 查找任意一个** stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); Optional<Integer> anyOptional = stream.filter(i -> i % 2 == 0).findAny(); System.out.println(anyOptional.get()); **2.3、没找到时，使用get（）会直接抛出异常提示信息，会提示错误：No value present** ```java stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); Optional<Integer> noNumOptional = stream.filter(i -> i == 11).findAny(); System.out.println(noNumOptional.get());抛出异常提示： //抛出异常提示：No value present ```` **2.4、没找到时，Optional输出：Optional.empty，不抛异常** System.out.println(noNumOptional); *输出结果：*Optional.empty **3、orElse 如果没查找返回给定的值** 范例： **需求：查询数组中是否包含指定值，没有返回默认值。** ***3.1、原始写法*** 先写个方法，然后调用/* * 原始写法，查询数组中是否包含指定值，没有返回默认值 * @param values * @param defaultValue * @param predicate * @return */ public static int findDifineValue(Integer[] values, int defaultValue, Predicate<Integer> predicate){ for(int i : values){ if(predicate.test(i)){ return i; } } return defaultValue; } 调用原始写法： int findValueResult = findDifineValue(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, -1, i -> i == 9); System.out.println(findValueResult); ***3.2、orElse写法*** // orElse写法 如果没查找返回给定的值 stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); Optional<Integer> noNumOptional = stream.filter(i -> i == 11).findAny(); System.out.println(noNumOptional.orElse(-1));比原始写法简写很多。 ---------- **4、isPresent 判断是否存在，直接返回boolean值** stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); boolean isPresent = stream.filter(i->i==4).findAny().isPresent(); System.out.println(isPresent); **5、存在就打印出来,没有则不打印** stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); stream.filter(i->i==6).findAny().ifPresent(System.out::println); ** 6、还可以进行二次过滤** stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); //先Stream的filter过滤,然后得到Optional,再用Optional的filter过滤 stream.filter(i->i>8).findAny().filter(i->i<10).ifPresent(System.out::println);## 五、Stream API：reduce：聚合作用，根据reduce传入的Function条件进行聚合  范例：package com.example.study.java8.streams;import java.util.Arrays;import java.util.List;/**Stream reduce：聚合作用，根据reduce传入的Function条件进行聚合用法：只要reduce里面参数满足funcion就可以 */public class StreamReduce {public static void main(String[] args) { //用法：只要reduce的参数满足Function就可以 //reduce(0, (i, j) -> i + j) List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1); Integer reduceResult = list.stream().reduce(0, (i, j) -> i + j); System.out.println(reduceResult); System.out.println("==================================="); //reduce((i,j)->i+j) list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1); list.stream().reduce((i,j)->i+j).ifPresent(System.out::println); System.out.println("==================================="); //reduce(Math::max) list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1); list.stream().reduce(Math::max).ifPresent(System.out::println); System.out.println("==================================="); //reduce(Integer::sum) list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,6,5,4,3,2,1); list.stream().reduce(Integer::sum).ifPresent(System.out::println); }}