java8新特性与使用场景

java8新特性

• Lambda 表达式类似于匿名内部类

(parameters) -> expression
(parameters) ->{ statements; }，可接受多个参数，参数类型可标识也可不标识，表达式只有一条语句可省略大括号
lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误
lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）
在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

• 方法引用

构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例
静态方法引用：它的语法是Class::static_method
特定类的任意对象的方法引用：它的语法是Class::method实例
特定对象的方法引用：它的语法是instance::method实例

• 函数式接口(Functional Interface)
  有@FunctionalInterface 的接口，且只有一个抽象方法才可被称为函数式接口
  函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法（默认方法，静态方法，public方法）的接口。
  函数式接口可以被隐式转换为 lambda 表达式
  可以使用Lambda表达式来表示该接口的一个实现
  示例

turn off
Java 8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错
GreetingService greetService1 = message -> System.out.println("Hello " + message);

• Stream

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等
stream of elements ±----> |filter±> |sorted±> |map±> |collect
集合接口有两个方法来生成流:stream()，parallelStream()
方法（参数为Lambda或无参等，视情况而定）:
filter, map, reduce, find, match, sorted，forEach，limit，Collectors，distinct
list.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList())

• Optional（容器）

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。

• Nashorn, JavaScript 引擎

Nashorn取代Rhino(JDK 1.6, JDK1.7)成为Java的嵌入式JavaScript引擎。Nashorn完全支持ECMAScript 5.1规范以及一些扩展。
它使用基于JSR 292的新语言特性，其中包含在JDK 7中引入的 invokedynamic，将JavaScript编译成Java字节码。
与先前的Rhino实现相比，这带来了2到10倍的性能提升。

• 新的日期时间 API（对时间进行处理）

• Base64（加密和解密）

double数据最好定义成BigDecimal,BigDecimal有一些方便的计算函数
个人理解流数据处理：流数据进入处理队列，流对象方法接收处理队列中的数据，放入函数式接口对象进行处理得到正确数据

• 接口
  加了static 和default的方法可以有方法体
  定义的变量默认为final，可被继承

简单实例

@FunctionalInterface
interface GreetingService {
    void sayMessage(String message);
}

public class Java8Class {

    public static void main(String[] args) {
        //create interface example - down java8
        new GreetingService() {
            @Override
            public void sayMessage(String message) {
                System.out.println(message);
            }
        }.sayMessage("create interface example - down java8");
        //create interface example - up java8
        GreetingService greetingService = System.out::println;
        greetingService.sayMessage("create interface example - up java8");
        //create Thread - down java8
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("create Thread - down java8");
            }
        }).start();
        //create Thread - up java8
        new Thread(() -> {
            System.out.println("create Thread - up java8");
        }).start();
        List<Object> asList = Arrays.asList("ni", "ce");
        //for list - down java8
        for (Object el : asList) {
            System.out.println("for list - down java8 " + el);
        }
        //for list - up java8
        asList.forEach(el -> {
            System.out.println("for list - up java8 " + el);
        });
    }
}

java8使用场景

• max,min,average,sum,count(统计)

  非对象属性：Arrays.asList(1, 2, 3).stream().mapToInt(Integer::intValue).max().getAsInt();
  对象属性：
  list.stream().map(User::getAge).min((a, b) -> a.compareTo(b));
  list.stream().map(User::getAge).min((a, b) -> a - b);
  list.stream().map(User::getAge).mapToInt(Integer::intValue).summaryStatistics().getMin();
  list.stream().map(User::getAge).mapToInt(Integer::intValue).min().getAsInt();

• map:一对一/flatMap:一对多(映射)

  参数+表达式：list.stream().map(a -> a + 1).collect(Collectors.toList());
  对象+方法：list.stream().map(String::toUpperCase).collect(Collectors.toList());
  Stream<List> inputStream = Stream.of(Arrays.asList(1),Arrays.asList(2, 3),Arrays.asList(4, 5, 6));
  Stream outputStream = inputStream.flatMap((childList) -> childList.stream());

• filter(过滤)

  list.stream().map(User::getAge).filter(a -> a != null).max((a, b) -> a.compareTo(b));

• foreach(遍历)

  forEach 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。
  list.stream().forEach(a-> System.out.println(a));
  另外一点需要注意，forEach 是 terminal 操作，因此它执行后，Stream 的元素就被“消费”掉了，你无法对一个 Stream 进行两次 terminal 运算。下面的代码是错误的：
  stream.forEach(element -> doOneThing(element));
  stream.forEach(element -> doAnotherThing(element));
  相反，具有相似功能的 intermediate 操作 peek 可以达到上述目的。如下是出现在该 api javadoc 上的一个示例。
  peek 对每个元素执行操作并返回一个新的 Stream
  Stream.of(“one”, “two”, “three”, “four”)
  . filter(e -> e.length() > 3)
  .peek(e -> System.out.println("Filtered value: " + e))
  .map(String::toUpperCase)
  .peek(e -> System.out.println("Mapped value: " + e))
  .collect(Collectors.toList());

• collect(集合转换)

  list.stream().collect(Collectors.toList());
  list.stream().collect(Collectors.toMap(a->a,a->a));
  list.stream().collect(Collectors.toSet());
  list.stream().collect(Collectors.toCollection(ArrayList::new));

• limit/skip

  limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素
  list.stream().limit(3).collect(Collectors.toList()); 返回集合前三个元素
  list.stream().skip(3).collect(Collectors.toList()); 返回集合前三个元素之后的元素

• reduce(计算)

  这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子）
  Integer sum = integers.reduce(0, (a, b) -> a+b); 或 Integer sum = integers.reduce(0, Integer::sum);

• sorted(排序)

  list.stream().limit(3).sorted((a, b) -> a.getAge().compareTo(b.getAge()));
  list.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(Comparator.comparing(User::getHight))).collect(Collectors.toList());

• distinct(去重)

  list.stream().limit(3).sorted((a, b) -> a.getAge().compareTo(b.getAge())).distinct();

• iterate(迭代，类似reduce)

  等差数列：Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));
  等比数列：Stream.iterate(0, n -> n 2).limit(10). forEach(x -> System.out.print(x + " "));

• Collectors(groupingBy/partitioningBy)

  java.util.stream.Collectors 类的主要作用就是辅助进行各类有用的 reduction 操作，例如转变输出为 Collection，把 Stream 元素进行归组
  eg1:list.stream().collect(Collectors.groupingBy(User::getAge));
  eg2:
  Map<Boolean, List> children = list.stream().limit(100).collect(Collectors.partitioningBy(p -> p.getAge() < 18));
  System.out.println("Children number: " + children.get(true).size());
  System.out.println("Adult number: " + children.get(false).size());

• generate(自己生成流)

  通过实现 Supplier 接口，你可以自己来控制流的生成。这种情形通常用于随机数、常量的 Stream，
  或者需要前后元素间维持着某种状态信息的 Stream。把 Supplier 实例传递给 Stream.generate() 生成的 Stream，
  默认是串行（相对 parallel 而言）但无序的（相对 ordered 而言）。 由于它是无限的，在管道中，必须利用 limit 之类的操作限制 Stream 大小。
  Random random = new Random(); Stream.generate(random::nextInt).limit(10).forEach(System.out::println);

• allMatch/anyMatch/noneMatch(匹配)

  allMatch：Stream 中全部元素符合传入的 predicate，返回 true
  anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
  noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

• Optional

  void ifPresent(Consumer<? super T> consumer) 如果值存在则使用该值调用 consumer , 否则不做任何事情。
  boolean isPresent() 如果值存在则方法会返回true，否则返回 false
  static Optional ofNullable(T value) 如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional
  T orElse(T other) 如果存在该值，返回值， 否则返回 other
  T orElseGet(Supplier<? extends T> other) 如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果
  eg:Optional.ofNullable("").get();