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();