JDK8特性与使用手记

新特性总览

• lambda表达式
• Stream操作数组
• Optional取代null
• 简洁的并发编程
• LocalDateTime新的时间API

Lambda表达式

• 概念：Lambda表达式是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应其中的Lambda抽象（lambda abstraction），是一个匿名函数，既没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义的不同）。你也可以理解为，简洁的表示可传递的匿名函数的一种方式：它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出异常的列表。

• 作用：既然是匿名函数，那就类比于匿名内部类的用法咯，哪些地方，会用到一些代码量大但实际逻辑不算复杂的方法调用，就可以用到它。

  什么是函数式接口？

  答：仅仅只有一个抽象方法的接口。

• 语法：

  • () -> 表达式
  • () -> {语句;}
  • () -> 对象
  • (Class)() -> {语句;}【指定对象类型】

    public static void doSomething(Runnable r) { r.run(); }
    public static void doSomething(Task a) { a.execute(); }
    ....
    doSomething(() -> System.out.println("DDDD"));
    // 为了避免隐晦的方法调用，尝试显式地类型转换
    doSomething((Runnable)() -> System.out.println("DDDD"));
    

• 使用场景（很多特殊场景都包含在内）
  总的来说，只有在接受函数式接口的地方才可以使用Lambda表达式。

  
  
  

  image.png

• 一些Jdk8的lambda语法糖：

  Lambda:(Apple a) -> a.getWeight() 
  方法引用:Apple::getWeight
  
  Lambda:() -> Thread.currentThread().dumpStack() 
  方法引用:Thread.currentThread()::dumpStack
    
  Lambda:(str, i) -> str.substring(i)
  方法引用:String::substring
    
  Lambda:(String s) -> System.out.println(s)
  方法引用:System.out::println
  

• 构造函数引用

  • 无参构造器

    Supplier c1 = Apple::new;
    Apple apple = c1.get();
    // 等价于
    Supplier c2 = () -> new Apple();
    

  • 一参构造器

    Function c1 = Apple::new;
    Apple apple = c1.apply(123);
    

  • 两参构造器

    BiFunction c1 = Apple::new;
    Apple apple = c2.apply(120, "red");
    

• 简化的数组排序

  apples.sort(comparing(Apple::getWeight));
  // 其中：
  // ArrayList.sort() since：1.2
  // Comparator.comparing(Function) since: 1.8
  

• 更复杂的数组排序

  • 倒序

    apples.sort(Comparator.comparing(Apple::getWeight).reversed());
    

  • 多条件排序

    apples.sort(Comparator.comparing(Apple::getWeight).reversed()
                .thenComparing(Apple::getCountry));
    

• Predicate的复合

  以下三个基本谓词，可以配合已有的谓词（Predicate），来制造出更加复杂的谓词。

  • negate：“非”

    private static  List filter(List list, Predicate predicate) {
        List result = new ArrayList<>();
        for (T t : list) {
            if (predicate.test(t)) {
                result.add(t);
            }
        }
        return result;
    }
    // 红苹果
    Predicate redApplePd = a -> "red".equals(a.getColor());
    // 不是红苹果
    Predicate notRedApplePd = a -> redApplePd.negate();
    // 过滤
    List redApple = filter(rawApples, redApplePd);
    List notRedApple = filter(rawApples, notRedApplePd);
    

  • and：“与”

    Predicate redHeavyApplePd = ((Predicate) apple -> apple.color.equals("red")).and(apple -> false);
    

  • or：“或”（同理）

• Function的复合

  • andThen
    f.andThen(g)相当于 g(f())，先执行f()，后执行g()

    Function dbSelf = x -> x * 2;
    Function oppositeNum = x -> -1 * x;
    Function toStr = String::valueOf;
    String result = dbSelf.andThen(oppositeNum).andThen(toStr).apply(1); // "-2"
    

  • compose
    f.compose(g)相当于 f(g())，先执行g()，后执行f()

    Function toStr = x -> "ToString:" + x;
    Function split = x -> x.split(":")[1];
    Function toInt = Integer::valueOf;
    int result = toInt.compose(split.compose(toStr)).apply(123); // 123
    

Stream

• 概念：流是Java API新成员，它允许你以声明性方式处理数据集合。
• 特点：
  • 流水线：类似“链式调用”，一步接一步。
  • 内部迭代：与使用迭代器显式迭代的集合不同，流的迭代操作是在背后进行的。
• 作用：
  • 减少for循环
  • 减少数组操作中可能声明的垃圾变量的数量
  • 直观、提高可读性
• 流和集合的区别：
  • 类似于看视频，无论点到视频的哪一段，它都能很快加载出来，这就是流。而集合相当于我要把整部电影down下来，才能点哪看哪。
  • 集合是内存中的数据结构，它包含数据结构中目前所有的值，集合中每个元素都需要事先计算好，才被放入集合。
  • 流是在概念上固定的数据结构，其元素时按需计算的（懒加载）。需要多少就给多少。换一个角度，流像是一个延迟创建的集合：只有在消费者要求的时候才会生成值。
• 看一个例子

  public List filterApple(List apples, Predicate criteria) {
        List result = new ArrayList<>();
        apples.forEach(apple -> {
            if (criteria.test(apple)) {
                result.add(apple);
            }
        });
        return result;
    }
  

  如果只用Lambda表达式，那操作数组起来，也还是需要一些for循环的加持。
  而有了Stream，写起code就简单很多了。

  List redHeavyApples = apples.stream()
    .filter(apple -> "red".equals(apple.color))
    .filter(apple -> apple.weight > 120)
    .collect(Collectors.toList());
  

• 相关包、类、方法
  • 包：java.util.stream
  • 接口：
    • BaseStream> extends AutoCloseable
    • Stream extends BaseStream>
    • DoubleStream extends BaseStream
    • IntStream extends BaseStream
    • LongStream extends BaseStream
  • 方法：
    • filter(Predicate):Stream
    • map(Function):Stream
    • mapToInt(ToIntFunction):LongStream
    • mapToDouble(ToDoubleFunction):DoubleStream
    • mapToLong
    • flatMap(Function>):Stream
    • flatMapToInt()
    • flatMapToLong()
    • flatMapToDouble()
    • distinct():Stream
    • sorted():Stream
    • sorted(Comparator):Stream
    • peek(Consumer):Stream
    • limit(long):Stream
    • skip(long):Stream
    • forEach(Consumer):void
    • forEachOrdered()
    • toArray():Object[]
    • toArray(IntFunction):Object[]
    • reduce(T, BinaryOperator):T
    • reduce(BinaryOperator):Optional
    • reduce(U, BiFunction, BinaryOperator):U
    • collect(Supplier, BiConsumer, BiConsumer):R
    • collect(Collector):R
    • min(Comparator):Optional
    • max
    • count():long
    • anyMatch(Predicate):boolean
    • allMatch
    • noneMatch
    • findFirst():Optional
    • findAny
    • builder():Builder
    • empty():Stream
    • of(T...):Stream
    • iterate(T, UnaryOperator):Steram
    • generate(Supplier):Stream
    • concat(Stream, Stream):Stream
• 例子：取重的绿苹果，然后升序排序，取它的重量

  List greenHeavyAppleWeight = apples.stream()
        .filter(apple -> apple.weight > 120)
        .filter(apple -> "green".equals(apple.color))
        .sorted(comparing(Apple::getWeight)) // Comparator.comparing()
        .map(apple -> apple.weight)
        .collect(toList()); // Collectors.toList()
  

• 流只能被消费一次

  List names = Arrays.asList("Java8", "Lambdas", "In", "Action");
    Stream s = names.stream();
    s.forEach(System.out::println);
    // 再继续执行一次，则会抛出异常
    s.forEach(System.out::println);
  

• 用flatMap()实现流的扁平化

  String[] words = {"Hello", "World"};
  Stream streamOfWords = Arrays.stream(words);
  
  // 没有打平，是两个 String[]，我需要两个嵌套for 循环来打印内容
  List a = streamOfWords.map(w -> w.split("")).collect(toList());
  for (String[] itemStrings: a) {
      System.out.println("item.length: " + itemStrings.length);
      for (String item: itemStrings) {
          System.out.print(item);
      }
      System.out.println();
  }
  

  没有打平，出来的是两个String[]，我需要两个嵌套for 循环来打印内容。而如果用flatMap：

  String[] words = {"Hello", "World"};
  Stream streamOfWords = Arrays.stream(words);
  
  // 打平，一个for循环就搞定
  List chars = streamOfWords
          .map(w -> w.split(""))
          .flatMap(Arrays::stream)
          .collect(toList());
  for (String item: chars) {
      System.out.print(item + "-");
  }
  

打平之后，直接操作一个数组就好。

• 例子：求最大最小值

  List numbers = Arrays.asList(2, 5, 3, 4, 1, 6, 3, 5);
  // way 1
  Integer max = numbers.stream().max(Integer::compareTo).orElse(null);
  // way 2
  max = numbers.stream().reduce(Integer::max).orElse(null);
  

• 原始类型流的特化（Stream转IntStream/LongStream/DoubleStream）

  作用：直接特化为原始类型：int、long、double，避免暗含的装箱成本。以及，有了一些额外的计算方法。

  • 映射到数值流：mapToInt/mapToLong/mapToDouble
  • 转回对象流：boxed
• 特化流的一下额外方法

  // 获得 1到100 的所有偶数
  IntStream.rangeClosed(1, 100).filter(num -> num%2 == 0).forEach(System.out::println);
  

• 构建流
  • 方式一：由值创建流

    Stream stream = Stream.of("Java8", "Lambda", "In");
    stream.map(String::toUpperCase).forEach(System.out::println);
    

  • 方式二：由数组创建流

    int[] nums = {2,4,6,7,8,12};
    int sum = Arrays.stream(nums).sum();
    

  • 方式三：由集合创建流

    List nums = Arrays.asList(1,2,3,4,5);
    Stream numStream = nums.stream();
    Stream parallelStream = nums.parallelStream();
    

  • 方式四：文件 + NIO 创建流

    利用 java.nio.file.Files中的一些静态方法（静态方法 since JDK1.8）都返回一个流。Filessince JDK1.7

    一个很有用的方法是 Files.lines ，它会返回一个由指定文件中的各行构成的字符串流。
    long uniqueWords; try (Stream lines = Files.lines(Paths.get(ClassLoader.getSystemResource("data.txt").toURI()), Charset.defaultCharset())) { uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" "))) .distinct() .count(); System.out.println("uniqueWords:" + uniqueWords); } catch (IOException e) { e.fillInStackTrace(); } catch (URISyntaxException e) { e.printStackTrace(); }

  • 方式五：由函数生成流

    以下两个操作，可以创建“无限流”，一般配合limit 使用
    Stream.iterate(<初始值>, <值的变化函数>)
    Stream.generate(Supplier s)
    

    不像从固定集合创建的流那样有固定大小的流。由 iterate和 generate 产生的流会用给定的函数按需创建值，因此可以无穷无尽地计算下去。

    // 迭代：每次返回前一个元素加2的值
    Stream.iterate(0, n -> n + 2)
        .limit(10)
        .forEach(System.out::println);
    

    // 生成：接收一个Supplier类型的函数（有出无入的函数）
    Stream.generate(Math::random)
        .limit(5)
        .forEach(System.out::println);
    

    看下面这个例子，对比Lambda表达式（匿名函数）和匿名内部类：

    // lambda
    IntStream twos = IntStream.generate(() -> 2);
    // 匿名内部类
    IntStream twos = IntStream.generate(new IntSupplier() {
        @Override
        public int getAsInt() {
            return 2;
        }
    });
    

    如果这个IntSupplier中不存在成员变量，那么，两者等价。总的来说，匿名内部类更加灵活，而且其output值不一定唯一不变，较为灵活。
• 收集器的用法
  • 接口：java.util.stream.Collector
  • 作用：对Stream的处理结果做收集。
  • 例子：

    • 分组

      List apples = Arrays.asList(
            new Apple(130, "red"),
            new Apple(22, "red"),
            new Apple(60, "green"),
            new Apple(162, "green"),
            new Apple(126, "green"),
            new Apple(142, "green"),
            new Apple(117, "green")
      );
      // 根据颜色分组
      Map> colorAppleMap = apples.stream().collect(groupingBy(apple -> apple.color));
      

    • 多级分组

      Map>> dishesByTypeCaloricLevel =
      menu.stream().collect(
              groupingBy(Dish::getType,
                      groupingBy(dish -> {
                          if (dish.getCalories() <= 400) {
                              return Dish.CaloricLevel.DIET;
                          } else if (dish.getCalories() <= 700) {
                              return Dish.CaloricLevel.NORMAL;
                          } else {
                              return Dish.CaloricLevel.FAT;
                          }
                      })
              )
      );
      

    • 分组的一些配合操作

      Stream.collect(groupingBy(Dish::getType, summingInt(Dish::getCalories)));
      Stream.collect(groupingBy(Dish::getType, mapping(...)));
      // 如：
      Map> caloricLevelsByType =
      menu.stream().collect(
           groupingBy(Dish::getType, mapping(
                dish -> {
                    if (dish.getCalories() <= 400) {
                        return Dish.CaloricLevel.DIET;
                    } else if (dish.getCalories() <= 700) {
                        return Dish.CaloricLevel.NORMAL;
                    } else {
                        return Dish.CaloricLevel.FAT;
                    }
                },
                toSet())));
      

    • 计数

      long count = apples.size();
      long count = apples.stream().collect(Collectors.counting());
      long count = apples.stream().count();
      

    • 汇总

      // 求和
      int totalWeight = apples.stream().collect(summingInt(Apple::getWeight));
      totalWeight = apples.stream().mapToInt(Apple::getWeight).sum();
      
      // 平均数
      double avgWeight = apples.stream().collect(averagingDouble(Apple::getWeight));
      avgWeight = apples.stream().mapToDouble(Apple::getWeight).average().orElse(-1);
      
      // 汇总
      IntSummaryStatistics appleStatistics = apples.stream().collect(summarizingInt(Apple::getWeight));
      System.out.println(appleStatistics.getMax());
      System.out.println(appleStatistics.getMin());
      System.out.println(appleStatistics.getAverage());
      System.out.println(appleStatistics.getCount());
      System.out.println(appleStatistics.getSum());
      

    • 连接字符串

      String[] strs = {"Hello", "World"};
      String result = Arrays.stream(strs).collect(joining([分隔符]));
      

    • 分区

      根据Predicate条件，分成true和false两部分集合。

      Map> partitionApples = apples.stream().collect(partitioningBy(apple -> "green".equals(apple.color)));
      

      看似没有什么特点，但是其实和grouping类似，有一个downStream:Collector的一个第二参数，这就厉害了，扩展性很强。

      // 先划分了素食和非素食，然后，每一类里面，去热量最高的一个。
      Map mostCaloricPartitionedByVegetarian = menu.stream().collect(
        partitioningBy(Dish::isVegetarian, collectingAndThen(
                maxBy(comparingInt(Dish::getCalories)),
                Optional::get
        )));
      

• 自定义流（这个就再说咯）
• 并行流

  相对于stream()，用parallelStream()就能把集合转换为并行流。

  • 概念：并行流就是一个把内容分成多个数据块，并用不同线程分别处理每个数据块的流。
  • 方法：

    切换为并行流：Stream.parallel()
    切换为顺序流：Stream.sequential()
    // 注意，谁最后调用，流就apply谁。
    

  • 用并行流之前，要测试性能（如果遇到iterator装包解包等的情况，实际上并行锁会更加慢，能用特化流就尽量用特化流）
  • Spliterator 定义了并行流如何拆分它要遍历的数据

Optional

• class：java.util.Optional
• 作用：解决和避免NPE异常
• Optional对象的方法
  • get()：不推荐使用。如果变量存在，它直接返回封装的变量值，否则就抛出一个NPE或者NoSuchElementException异常。

    Optional方法	调用get()后抛出异常
    Optional.of(null)	java.lang.NullPointerException
    Optional.ofNullable(null)	java.util.NoSuchElementException

  • orElse(T other)
  • orElseGet(Supplier other)：orElse的延迟调用版，Supplier方法只有在Optional对象不含值时才执行。
    • 适用场景：
      • 创建默认值是耗时的工作。
      • 或者需要十分确定某个方法仅在Optional为空时才调用。

    Person p1 = null;
    Optional optP1 = Optional.ofNullable(p1);
    Person resultP = optP1.orElseGet(() -> {
        Person p = new Person();
        p.firstName = "Fang";
        return p;
    });
    System.out.println("resultP.firstName: " + resultP.firstName);
    

  • orElseThrow(Supplier exceptionSupplier)：定制抛出的异常。
  • ifPresent(Consumer)：当变量值存在时执行一个作为参数传入的方法，否则不做任何操作。

    Person p1 = new Person();
    Optional optP1 = Optional.ofNullable(p1);
    optP1.ifPresent(person -> System.out.println("Haha"));
    

  • filter

    Person p1 = new Person();
    p1.firstName="Fang";
    p1.lastName="Hua";
    Person resP = Optional.ofNullable(p1).filter(person -> "Hua".equals(person.lastName)).orElseGet(() -> {
        Person newP = new Person();
        newP.firstName= "Ming";
        return newP;
    });
    System.out.println(resP.firstName); // Ming
    

  • 当然，还有一些方法与Stream接口相似，如map和flatMap
• 例子：
  • 对象嵌套取值
    • old

      @Test
      public void test_optional_1() {
          Person person = new Person();
          // 当然从重构角度来看，这里是不对的，我们知道太多这个类内部的东西，是需要重构的
          String name = person.getCar().getInsurance().getName();
      }
      public class Person {
          private Car car;
          public Car getCar() { return car; }
      }
      public class Car {
          private Insurance insurance;
          public Insurance getInsurance() { return insurance; }
      }
      public class Insurance {
          private String name;
          public String getName() { return name; }
      }
      

    • new

      public String getCarInsuranceName(Person person) {
          return Optional.ofNullable(person).flatMap(Person::getCar)
                  .flatMap(Car::getInsurance)
                  .map(Insurance::getName)
                  .orElse("Unknown");
      }
      
      public class Person {
          private String sex;
          private String firstName;
          private String lastName;
          private Optional car = Optional.empty();
      
          public Optional getCar() {
              return car;
          }
      }
      
      public class Car {
          private Optional insurance = Optional.empty();
      
          public Optional getInsurance() {
              return insurance;
          }
      }
      
      public class Insurance {
          private String name;
      
          public String getName() {
              return name;
          }
      }
      

  • 封装可能为空的值

    Object value = map.get("key");
    // 加上 Optional
    Optional