Java8实战 阅读笔记

lambda

1. 组成

   Comparator byWeight =(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
   
   Lambda表达式由参数、箭头和主体组成
   

2. 示例

    使用案例             Lambda示例
   
   布尔表达式           (List list) -> list.isEmpty()
   创建对象             () -> new Apple(10)
   消费一个对象         (Apple a) -> {
                               System.out.println(a.getWeight());
                               }
   从一个对象中选择/抽取  (String s) -> s.length()
   组合两个值            (int a, int b) -> a * b
   比较两个对象          (Apple a1, Apple a2) ->a1.getWeight().compareTo(a2.getWeight())
   

3. 常用的函数式接口

   函数式接口           函数描述符
   
   Predicate        T->boolean
   Consumer         T->void
   Function       T->R
   Supplier         ()->T
   UnaryOperator    T->T
   BinaryOperator   (T,T)->T
   BiPredicate    (L,R)->boolean 
   BiConsumer     (T,U)->void
   BiFunction   (T,U)->R
   

4. Lambdas及函数式接口的例子

   布尔表达式
   (List list) -> list.isEmpty()           Predicate>
   
   创建对象
   () -> new Apple(10)                             Supplier
   
   消费一个对象
   (Apple a) ->System.out.println(a.getWeight())   Consumer
   
   从一个对象中选择/提取
   (String s) -> s.length()                        Function 或ToIntFunction
   
   合并两个值
   (int a, int b) -> a * b                         IntBinaryOperator
   
   比较两个对象
   (Apple a1, Apple a2) ->
   a1.getWeight().compareTo(a2.getWeight())        Comparator 或BiFunction或 ToIntBiFunction
   

流

1.流简介

List names=munu.stream()                      //集合流
                    .filter(d->d.getCalories()>300)   //筛选热量大于300的  
                    .map(d->d.getName())                  //提取菜单的名字
                    .limit(3)                         //取前3个
                    .collect(toList());               //将流转换为List

2.中间操作

filter      中间       T->boolean
map         中间       T->R
limit       中间       取流前n个元素，是否有序取决于所取流是否有序 
skip        中间       返回一个扔掉前n个元素的流；如果流中元素不足n个，则返回一个空流    
sorted      中间       (T,T)->int
distinct    中间       去重
flatMap     中间       把流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流
forEach     终端       消费流中的每个元素并对其应用Lanbda。这一操作返回void
count       终端       返回流中元素的个数。这一操作返回long
collect     终端       把流归约成一个集合，比如List、Map甚至是Integer
allMatch    终端       T->boolean
anyMatch    终端       T->boolean
noneMatch   终端       T->boolean
findFirst   终端       T->Optionnal
findAny     终端       T->Optionnal
reduce      终端       （T，T）->T

3.构建流

1. 由值创建流

   Stream.of(“123”,”456”);

2. 由数组创建流

   Arrays.stream(…);

3. 由文件生成流

   long uniqueWords = 0;

   try(
   Stream lines =Files.lines(Paths.get(“data.txt”),Charset.defaultCharset())){
   uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(” “)))
   .distinct()
   .count();
   }catch(IOException e){
   }

4. 由函数生成流：创造无限流

   Stream API提供了两个静态方法来从函数生成流： Stream.iterate 和 Stream.generate 。

   1. iterate 方法接受一个初始值（在这里是 0 ），还有一个依次应用在每个产生的新值上的Lambda

      Stream.iterate(0, n -> n + 2)
      .limit(10)
      .forEach(System.out::println);

   2. 与 iterate 方法类似， generate 方法也可让你按需生成一个无限流

      Stream.generate(Math::random)
      .limit(5)
      .forEach(System.out::println);

用流收集数据

1. 分组：…collect(groupingBy(…))
2. 计数：…collect(counting()) 或 menu.stream().count();
3. 最大值和最小值：…collect(maxBy(…))和…collect(minBy(…))
4. 汇总：…collect(summingInt())
5. 求和：…collect(averagingInt())
6. 连接字符串：…collect(joining())
7. 分区：…collect(partitioningBy(…))

并行数据处理与性能

1. 调用 parallel 方法将顺序流转换为并行流

   public static long parallelSum(long n) {
   return Stream.iterate(1L, i -> i + 1)
   .limit(n)
   .parallel()
   .reduce(0L, Long::sum);
   }

2. 并行与顺序间切换

   stream.parallel()
   .filter(…)
   .sequential()
   .map(…)
   .parallel()
   .reduce();

3. 正确使用并行流

   1. 留意装箱
   2. 有些操作本身在并行流上的性能就比顺序流差。特别是 limit 和 findFirst 等依赖于元素顺序的操作，它们在并行流上执行的代价非常大。
   3. 对于较小的数据量，选择并行流几乎从来都不是一个好的决定
   4. 要考虑流背后的数据结构是否易于分解。例如， ArrayList 的拆分效率比 LinkedList高得多，因为前者用不着遍历就可以平均拆分，而后者则必须遍历。
   5. 流自身的特点

默认方法

对库开发者重要，接口中新增方法，提供默认实现。之前实现了该接口的用户 不用修改 实现了该接口的类，以便接口可平滑过渡。为避免冲突，有同名方法，它会优先使用类内方法，然后是更具体的接口默认方法，或者显式调用