[新]Java8的新特性

原文首发在我的博客：https://blog.liuzijian.com/post/86955c3b-9635-47a0-890c-f1219a27c269.html
1.Lambda表达式

　　lambda表达式是Java8的重要更新，lambda表达式可以用更简洁的代码来创建一个只有一个抽象方法的接口（函数式接口）的实例，从而更简单的创建匿名内部类的对象。
语法和使用

　　lambda表达式的基本语法是形参列表（可以省略范例），箭头，以及代码块，比方() -> {}，或者(x, y) -> {}，如果只有一个参数，那么小括号()可以省略，如果代码块只有一条语句，那么代码块的花括号{}可一并省略，如果代码块内只有一处return，那么return也可一并省略。
例: TreeSet类的构造器需要传进去一个Comparator的匿名类对象进去，来进行排序，所以程序实现了一个匿名内部类来封装处理举动，而且不得不用匿名内部类的语法来封装对象。

1. @Test
2. public void test() {
4.     TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {
5.         @Override
6.         public int compare(Integer o1, Integer o2) {
7.             return Integer.compare(o1, o2);
8.         }
9.     });
11.     treeSet.add(20);
12.     treeSet.add(78);
13.     treeSet.add(-98);
14.     System.out.println(treeSet);
15. }

复制代码

Comparator接口是一个函数式接口，因此完全可以使用lambda表达式来简化创建匿名内部类对象，因此上面代码可以修改成如许

1. @Test
2. public void test() {
3.     TreeSet<Integer> treeSet = new TreeSet<>((Integer x, Integer y) -> {
4.         return x.compareTo(y);
5.     });
6.     treeSet.add(20);
7.     treeSet.add(78);
8.     treeSet.add(-98);
9.     System.out.println(treeSet);
10. }

复制代码

进一步简化: 参数范例可以省略，如果代码块只有一条语句，那么代码块的花括号{}可一并省略，如果代码块内只有一处return，那么return也可一并省略

1. @Test
2. public void test() {
3.     TreeSet<Integer> treeSet = new TreeSet<>((x, y) -> x.compareTo(y));
4.     treeSet.add(20);
5.     treeSet.add(78);
6.     treeSet.add(-98);
7.     System.out.println(treeSet);
8. }

复制代码

　　逻辑与上面代码是完全雷同的，只是不再需要new Xxx() {}这种繁琐的语法，不需要指出重写方法的名字，也不需要给出重写方法的返回值范例，只需要给出重写方法的括号以及括号内的形参变量即可，用lambda表达式的代码块代替掉匿名内部类抽象方法的方法体，lambda表达式在这里就像是一个匿名方法。
方法引用和构造器引用

　　前面说过如果花括号只有一条代码，便可以省略花括号，不但云云，还可以使用方法引用和构造器引用，使得lambda表达式变得再简洁一些，方法引用和构造器引用的语法是两个英文冒号::，支持以下使用方式
种类语法说明lambda表达式写法类方法类名::类方法抽象方法全部参数传给该类某个方法作为参数(a,b,...) -> 类名.类方法(a,b,...)特定对象实例方法特定对象::实例方法抽象方法全部参数传给该方法作为参数(a,b,...) -> 特定对象.实例方法(a,b,...)某类对象实例方法类名::实例方法抽象方法第一个参数作为调用者，后面的参数全部传给该方法作为参数(a,b,c,...) -> a.实例方法(b,c,...)构造器类名::new抽象方法全部参数传给该构造器作为参数(a,b,...) -> new 类名(a,b,...)例: 类名::类方法

1. @FunctionalInterface
2. interface Convert {
3.     Integer fun(String s);
4. }
6. @Test
7. public void test8() {
8.     Convert convert =  from -> Integer.valueOf(from);
9.     System.out.println(convert.fun("150") + 1);
11. }
13. @Test
14. public void test9() {
15.     Convert convert = Integer::valueOf;
16.     System.out.println(convert.fun("150") + 1);
17. }

复制代码

例: 特定对象::实例方法

1. @FunctionalInterface
2. interface Convert {
3.     Integer fun(String s);
4. }
6. @Test
7. public void test8() {
8.     Convert convert = from -> "liuzijian.com".indexOf(from);
9.     System.out.println(convert.fun("zi"));
10. }
12. @Test
13. public void test9() {
14.     Convert convert = "liuzijian.com"::indexOf;
15.     System.out.println(convert.fun("zi"));
16. }

复制代码

例: 类名::实例方法

1. @FunctionalInterface
2. interface Fun {
3.     String test(String a, int b, int c);
4. }
6. @Test
7. public void test8() {
8.     Fun fun = (a, b, c) -> a.substring(b, c);
9.     String s = fun.test("abcdefghi", 3, 5);
10.     System.out.println(s);
11. }
13. @Test
14. public void test9() {
15.     Fun fun = String::substring;
16.     String s = fun.test("abcdefghi", 3, 5);
17.     System.out.println(s);
18. }

复制代码

例: 类名::new

1. @FunctionalInterface
2. interface Fun {
3.     BigDecimal test(String n);
4. }
6. @Test
7. public void test8() {
8.     Fun fun = (n) -> new BigDecimal(n);
9.     BigDecimal b = fun.test("45.64");
10.     System.out.println(b);
11. }
13. @Test
14. public void test9() {
15.     Fun fun = BigDecimal::new;
16.     BigDecimal b = fun.test("45.64");
17.     System.out.println(b);
18. }

复制代码

2.函数式接口

　　在Java8中，引入了函数式接口的概念，函数式接口是一个只有一个抽象方法的接口，通常用于Lambda表达式和方法引用，函数式接口可以有多个默认方法或静态方法，但是必须只有一个抽象方法
定义

1. @FunctionalInterface
2. public interface MyPredicate<T> {
3.    
4.     boolean fun(T obj);
5.    
6.     default void other() {
7.         System.out.println("hello world");
8.     }
10.     static void staticMethod() {
11.         System.out.println("static method");
12.     }
13. }

复制代码

　　@FunctionalInterface注解：这是一个可选的注解，它可以资助编译器在编译时检查接口是否符合函数式接口的要求，即是否只有一个抽象方法，如不符合还加这个注解，会导致编译器报错。
使用

编写一个实体类Employee

1. @Data
2. @AllArgsConstructor
3. @NoArgsConstructor
4. @ToString
5. public class Employee {
6.     private String name;
7.     private Double salary;
8.     private Integer age;
10.     public Employee(Integer age) {
11.         this.age = age;
12.     }
14.     public Employee(Integer age, String name) {
15.         this.age = age;
16.         this.name = name;
17.     }
18. }

复制代码

新增一个按条件过滤的方法filter，将List作为第一个参数，函数式接口MyPredicate作为第二个参数传进filter()方法，方法体内循环将每个Employee对象一一作为参数传入接口的抽象方法fun()中，并调用，根据抽象方法运行后得到的布尔值判断是否过滤掉。

1. private List<Employee> filter(List<Employee>employees, MyPredicate<Employee> predicate) {
2.     List<Employee>list = new ArrayList<>();
3.     for (Employee e : employees) {
4.         if (predicate.fun(e)) {
5.             list.add(e);
6.         }
7.     }
8.     return list;
9. }

复制代码

声明一个员工集合employees，插入5个对象，然后调用filter()方法，将employees作为第一个参数传入，然后直接new一个实现MyPredicate接口抽象方法的匿名内部类作为第二个参数传入，如许一来，调用时既告诉了目标方法filter()要处理的数据是employees，也一并将数据的具体处理规则obj.getAge() > 16告诉了目标方法，调用同一个方法可以有无数种处理数据的策略，这个现实上就是一种典范的策略模式，现实上Java8已经为我们写好了一种策略模式的函数式接口。

1. private List<Employee> employees = Arrays.asList(
2.     new Employee("soo", 8547.322, 17),
3.     new Employee("lili", 1000D, 15),
4.     new Employee("王萌", 2154D, 16),
5.     new Employee("张帆", 8547.322, 22),
6.     new Employee("goog", 353D, 12)
7. );
9. @Test
10. public void test3() {
12.     List<Employee>list = filter(employees, new MyPredicate<Employee>() {
13.         @Override
14.         public boolean fun(Employee obj) {
15.             return obj.getAge() > 16;
16.         }
17.     });
19.     System.out.println(list);
20. }

复制代码

Java8中，通过将策略接口实现简写为Lambda表达式的方式，可以使得语法显得更加简洁

1. List<Employee>list2 = filter(employees, (e) -> e.getAge() < 16);

复制代码

内置的函数式接口

Java8提供了一些预定义的函数式接口，位于java.util.function包中

• java.util.function.Consumer 消费
  
• java.util.function.Supplier 供给
  
• java.util.function.Function 函数
  
• java.util.function.Predicate 断言
  
• java.util.function.BinaryOperator 不常用
  
• java.util.function.UnaryOperator 不常用
  

编写4个将函数式接口作为参数的方法

1. private void testConsumer(String str, Consumer<String>consumer) {
2.     consumer.accept(str);
3. }
5. private String testSupplier(Supplier<String>supplier) {
6.     return supplier.get();
7. }
9. private Integer testFunction(String str, Function<String, Integer>function) {
10.     return function.apply(str);
11. }
13. private boolean testPredicate(String str, Predicate<String>predicate) {
14.     return predicate.test(str);
15. }

复制代码

分别调用这些方法，按照业务逻辑通过匿名内部类的lambda表达式写法实现函数式接口的抽象方法，作为参数传入

1. @Test
2. public void test4() {
4.     testConsumer("hello lambda", (x) -> System.out.println(x));
6.     String str = testSupplier(() -> { return "hello world"; });
7.     System.out.println(str);
9.     Integer integer = testFunction("66", (x) -> Integer.valueOf(x));
10.     System.out.println(integer);
12.     boolean b = testPredicate("hello", (e) -> e.equals("hello"));
13.     System.out.println(b);
15. }

复制代码

得到运行效果

1. hello lambda
2. hello world
3. 66
4. true

复制代码

还可以通过lambda表达式的方法引用和构造器引用将调用修改的更简洁一些

1. @Test
2. public void test2() {
3.     testConsumer("hello lambda", System.out::println);
5.     Integer integer = testFunction("66", Integer::valueOf);
6. }

复制代码

3.Stream API

　　Stream是Java8引入的一个新特性，是一个数据流，它提供了一种声明性的方法来处理集合、数组等数据源中的数据，可以更简洁、函数式的方式进行数据处理，它不会改变数据源本身，而是返回一个新的Stream或者是最终的效果。
Java8中引进的常见流式API包括:

• java.util.stream.Stream
  
• java.util.stream.LongStream
  
• java.util.stream.IntStream
  
• java.util.stream.DoubleStream
  

此中java.util.stream.Stream是个通用的流接口，以外的几种则代表流的元素范例为long，int，double
　　Stream操作是延伸实行的，这意味着它们会比及需要效果时在实行，Stream操作可以被链式调用，而且一样平常分为两类操作：中间操作和停止操作
创建Stream

从集合范例的stream()方法创建

1. List<String> list = new ArrayList<>();
2. Stream<String> stream = list.stream();

复制代码

从数组创建

1. Employee[] employees = new Employee[10];
2. Stream<Employee> employeeStream = Arrays.stream(employees);

复制代码

通过Stream的静态方法创建流

1. Employee[] employees = new Employee[10];
2. Stream<Employee> employeeStream1 = Stream.of(employees);

复制代码

迭代创建无穷流，根据种子和消费接口

1. Stream.iterate(10, (x) -> x + 2)
2.       .limit(10)
3.       .forEach(System.out::println);

复制代码

随机数

1. Stream.generate(Math::random)
2.         .limit(20)
3.         .forEach(System.out::println);

复制代码

通过builder()创建一个int流

1. @Test
2. public void test5() {
3.    
4.     IntStream intStream = IntStream.builder()
5.             .add(1)
6.             .add(2)
7.             .add(3)
8.             .add(4).build();
10.     // 下面的聚集方法每次只能执行一行
11.     System.out.println(intStream.max().getAsInt());
12.     //System.out.println(intStream.min().getAsInt());
13.     //System.out.println(intStream.sum());
14.     //System.out.println(intStream.count());
15.     //System.out.println(intStream.average());
16. }

复制代码

Stream的操作

　　Stream的操作包罗中间操作和停止操作，在《疯狂Java讲义》一书中，李刚老师也将其称为中间方法和末了方法，中间操作允许流保持打开状态，并允许直接调用后续方法，中间方法返回值是另一个流。停止方法是对流的最终操作，在对某个流实行停止操作后，整个流将不再可用。
常见中间操作

• filter(Predicate predicate) 过滤流中不符合predicate的元素
  
• mapToXxx(ToXxxFunction mapper) 使用ToXxxFunction对流中的元素进行一对一转换。返回的新流中包罗ToXxxFunction转换天生的全部元素
  
• peek(Consumer action) 依次对每个元素实行了一些操作，返回的流与原有的流包罗雷同的元素（多用于调试）
  
• distinct() 扫除流中全部重复元素，判断标准是equals()返回true
  
• sorted() 该方法用于排序
  
• sorted(Comparator comparator) 该方法用于根据自定义规则排序
  
• limit(long maxSize) 截取流中的前maxSize个元素
  
• skip(long n) 跳过流中的前n个元素
  
• map(Function mapper) 映射每个元素为其他形式
  
• flatMap(Function mapper) 将每个元素转换为一个流，然后将多个流合并成一个流
  

常见停止操作

• collect(Collector collector) 将流中的元素收集到一个容器中（如集合、列表、映射等）
  
• count() 返回流中的元素个数
  
• forEach(Consumer action) 遍历流中全部元素，对每个元素实行action
  
• toArray() 将流中全部元素转换为一个数组
  
• reduce() 通过某种操作来合并流中的元素
  
• min() 返回流中元素的最小值
  
• max() 返回流中元素的最大值
  
• anyMatch(Predicate predicate) 如果流中任一元素匹配给定条件，返回 true
  
• allMatch(Predicate predicate) 如果流中全部元素都匹配给定条件，返回 true
  
• noneMatch(Predicate predicate) 如果流中没有任何元素匹配给定条件，返回 true
  
• findFirst() 返回流中的第一个元素
  
• findAny() 返回流中的任意一个元素
  

中间操作返回的是一个新的Stream，而且中间操作是惰性实行的，直到停止操作才触发盘算
下面是用例:
数据:

1. private List<Employee> employees = Arrays.asList(
2.     new Employee("soo", 8547.322, 17),
3.     new Employee("lili", 1000D, 18),
4.     new Employee("王萌", 2154D, 16),
5.     new Employee("张帆", 8547.322, 22),
6.     new Employee("张帆", 8547.322, 22),
7.     new Employee("张帆", 8547.322, 22),
8.     new Employee("goog", 353D, 12)
9. );
11. private List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");

复制代码

例: stream+limit筛选切片，满意e.getAge() > 16条件的对象达到两个时就停止迭代，而不是迭代一遍后返回前两个，进步效率。停止操作forEach()不触发，中间操作filter()，limit()也不会得到实行。

1. @Test
2. public void test() {
3.     employees.stream()
4.     .filter((e) -> {
5.         // 中间操作
6.         System.out.println("中间操作");
7.         return e.getAge() > 16;
8.     })
9.     .limit(2) //中间操作
10.     .forEach(System.out::println); //终止操作
11.    
12. }

复制代码

运行效果:

1. 中间操作
2. Employee(name=soo, salary=8547.322, age=17)
3. 中间操作
4. Employee(name=lili, salary=1000.0, age=18)

复制代码

例: 跳过流中的前n个元素，与limit相反

1. @Test
2. public void test2() {
3.     employees.stream().skip(2).forEach(System.out::println);
4. }

复制代码

运行效果

1. Employee(name=王萌, salary=2154.0, age=16)
2. Employee(name=张帆, salary=8547.322, age=22)
3. Employee(name=张帆, salary=8547.322, age=22)
4. Employee(name=张帆, salary=8547.322, age=22)
5. Employee(name=goog, salary=353.0, age=12)

复制代码

例: 去重，根据equals，hashCode，本例去重成功的前提是Employee类需要重写equals，hashCode

1. //Employee类重写equals hashCode
3. @Override
4. public boolean equals(Object o) {
5.     if (this == o) return true;
6.     if (o == null || getClass() != o.getClass()) return false;
8.     Employee employee = (Employee) o;
10.     if (!Objects.equals(name, employee.name)) return false;
11.     if (!Objects.equals(salary, employee.salary)) return false;
12.     return Objects.equals(age, employee.age);
13. }
15. @Override
16. public int hashCode() {
17.     int result = name != null ? name.hashCode() : 0;
18.     result = 31 * result + (salary != null ? salary.hashCode() : 0);
19.     result = 31 * result + (age != null ? age.hashCode() : 0);
20.     return result;
21. }

复制代码

1. @Test
2. public void test3() {
3.     employees.stream().distinct().forEach(System.out::println);
4. }

复制代码

运行效果

1. Employee(name=soo, salary=8547.322, age=17)
2. Employee(name=lili, salary=1000.0, age=18)
3. Employee(name=王萌, salary=2154.0, age=16)
4. Employee(name=张帆, salary=8547.322, age=22)
5. Employee(name=goog, salary=353.0, age=12)

复制代码

例: flatMap将流中每个值，都转换成另一个流，然后把全部流连接成一个
下面程序先将"aaa"转换成由3个'a'构成的List，再将List转换为Stream，"bbb"和 "ccc"同理，最后将转换成的三个Stream合并为含有9个元素的Stream，再调用结束方法collect()将其变为含有9个元素的List，依次打印输出。

1. @Test
2. public void test5() {
4.     List<String> list = Arrays.asList("aaa", "bbb", "ccc");
5.    
6.     Function<String, Stream<Character>> function = (e) -> {
7.         List<Character> characters = new ArrayList<>();
9.         for (char c : e.toCharArray()) {
10.             characters.add(c);
11.         }
13.         return characters.stream();
14.     };
16.     List<Character> collect = list.stream()
17.                 .flatMap(function)
18.                 .collect(Collectors.toList());
20.     collect.forEach(System.out::println);
21. }

复制代码

运行效果

1. a
2. a
3. a
4. b
5. b
6. b
7. c
8. c
9. c

复制代码

例: map映射，得到流中的一个元素，处理组成新的流

1. @Test
2. public void test4() {
3.     employees.stream().map((e) -> e.getName()).forEach(System.out::println);
4. }

复制代码

运行效果

1. soo
2. lili
3. 王萌
4. 张帆
5. 张帆
6. 张帆
7. goog

复制代码

例: sorted()天然排序

1. @Test
2. public void test() {
3.     list.stream().sorted().forEach(System.out::println);
4. }

复制代码

运行效果

1. a
2. a
3. a
4. b
5. b
6. b
7. c
8. c
9. cdddeee

复制代码

例: sorted(Comparator c)定制排序

1. @Test
2. public void test2() {
3.     employees.stream()
4.             .sorted((e1, e2) -> e1.getAge() - e2.getAge())
5.             .forEach(System.out::println);
7. }

复制代码

运行效果

1. Employee(name=goog, salary=353.0, age=12)
2. Employee(name=王萌, salary=2154.0, age=16)
3. Employee(name=soo, salary=8547.322, age=17)
4. Employee(name=lili, salary=1000.0, age=18)
5. Employee(name=张帆, salary=8547.322, age=22)
6. Employee(name=张帆, salary=8547.322, age=22)
7. Employee(name=张帆, salary=8547.322, age=22)

复制代码

例: xxxMatch，findXXX，count()，max()，min()

1. @Test
2. public void test3() {
3.     boolean b = employees.stream().allMatch((e) -> e.getAge() > 10);
4.     System.out.println(b);
6.     b = employees.stream().anyMatch((e) -> e.getAge() > 100);
7.     System.out.println(b);
9.     b = employees.stream().noneMatch((e) -> e.getAge() > 100);
10.     System.out.println(b);
12.     Optional<Employee> first = employees.stream().findFirst();
13.     System.out.println(first.get());
15.     Optional<Employee> any = employees.stream().findAny();
16.     System.out.println(any.get());
18.     long count = employees.stream().count();
19.     System.out.println(count);
21.     Optional<Employee> max = employees.stream()
22.             .max(Comparator.comparingInt(Employee::getAge));
24.     System.out.println(max.get());
26.     Optional<Integer> maxAge = employees.stream()
27.             .map(Employee::getAge)
28.             .max(Integer::compare);
30.     System.out.println(maxAge.get());
31. }

复制代码

运行效果

1. true
2. false
3. true
4. Employee(name=soo, salary=8547.322, age=17)
5. Employee(name=soo, salary=8547.322, age=17)
6. 7
7. Employee(name=张帆, salary=8547.322, age=22)
8. 22

复制代码

例: reduce() 将流中元素反复结合，得到新值，先将起始值作为x，从流中取出一个值作为y

1. @Test
2. public void test() {
3.     List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
5.     Integer sum = list.stream().reduce(0, Integer::sum);
6.     System.out.println(sum);
7.    
8.     Optional<Double> reduce = employees.stream().map(Employee::getSalary)
9.             .reduce(Double::sum);
10.     System.out.println(reduce.get());
11. }

复制代码

运行效果

1. 45
2. 37696.288

复制代码

例: .collect(Collectors.toList()) .collect(Collectors.toCollection()) 收集为集合

1. @Test
2. public void test2() {
3.     List<String> names = employees.stream()
4.             .map(Employee::getName)
5.             .collect(Collectors.toList());
7.             //.collect(Collectors.toCollection(LinkedList::new))
8.    
9.     names.forEach(System.out::println);
10. }

复制代码

运行效果

1. soo
2. lili
3. 王萌
4. 张帆
5. 张帆
6. 张帆
7. goog

复制代码

例: collect(Collectors.averagingDouble()) 求平均值

1. @Test
2. public void test5() {
3.     Double avg = employees.stream()
4.             .collect(Collectors.averagingDouble(Employee::getSalary));
6.     System.out.println(avg);
7. }

复制代码

例: collect(Collectors.joining()) 用雷同的内容连接多个字符串，非常适合SQL等参数拼接场景

1. @Test
2. public void test() {
3.     String collect = list.stream().collect(Collectors.joining(","));
4.     System.out.println(collect);
5. }

复制代码

运行效果

1. aaa,bbb,ccc,ddd,eee

复制代码

例: 收集为Map Collectors.groupingBy()
将雷同航司和票号的票和行李的代价加在一起

1. public class TestGroupBy {
2.    
3.     private List<Detail> details = new ArrayList<>();
4.    
5.     @Before
6.     public void mock() {
7.         details.add(new Detail(1, "001", "123456789", new BigDecimal("120.00")));
8.         details.add(new Detail(2, "001", "123456789", new BigDecimal("99.32")));
9.         
10.         details.add(new Detail(3, "003", "333222111", new BigDecimal("27.32")));
11.         details.add(new Detail(4, "003", "333222111", new BigDecimal("36.00")));
12.         details.add(new Detail(5, "003", "123456789", new BigDecimal("48.32")));
13.         
14.         details.add(new Detail(6, "101", "123456789", new BigDecimal("53.32")));
15.         details.add(new Detail(7, "101", "123456789", new BigDecimal("10.32")));
16.         details.add(new Detail(8, "102", "333222111", new BigDecimal("3.32")));
17.         details.add(new Detail(9, "103", "123456789", new BigDecimal("9.00")));
18.         details.add(new Detail(10, "103", "123456789", new BigDecimal("12.12")));
19.         
20.     }
21.    
22.     @Test
23.     public void test() {
24.         Map<String, List<Detail>> groupByAir = details.parallelStream().collect(Collectors.groupingBy(Detail::getAir));
25.         groupByAir.forEach((air, sameAirs) -> {
26.             Map<String, List<Detail>> groupByDoc = sameAirs.parallelStream().collect(Collectors.groupingBy(Detail::getDocument));
27.             groupByDoc.forEach((doc, sameDocs) -> {
28.                 Optional<BigDecimal> reduce = sameDocs.parallelStream().map(Detail::getPrice).reduce(BigDecimal::add);
29.                 reduce.ifPresent(e -> {
30.                     System.out.println(air + " "+ doc + " " + e);
31.                 });
32.             });
33.         });
34.     }
35.    
38.     @Data
39.     @AllArgsConstructor
40.     public static class Detail {
41.         /**
42.          * ID
43.          */
44.         private Integer id;
45.         /**
46.          *航司编码
47.          */
48.         private String air;
49.         /**
50.          *票号
51.          */
52.         private String document;
53.         /**
54.          *机票价格
55.          */
56.         private BigDecimal price;
57.     }
58.    
59. }

复制代码

运行效果

1. 001 123456789 219.32
2. 101 123456789 63.64
3. 102 333222111 3.32
4. 003 333222111 63.32
5. 003 123456789 48.32
6. 103 123456789 21.12

复制代码

例: peek() 实时打印调试看流处理的每一步里面的元素是什么样的

1. @Test
2. public void test6() {
3.     List<String> names = Arrays.asList("liuzijian", "liutongtong", "zhaoying", "wangwendi");
5.     names.stream()
6.             .filter(name -> name.startsWith("liu"))
7.             .peek(name -> System.out.println("过滤后: " + name))
8.             .map(String::toUpperCase)
9.             .peek(name -> System.out.println("变成大写后: " + name))
10.             .collect(Collectors.toList());
11. }

复制代码

运行效果

1. 过滤后: liuzijian
2. 变成大写后: LIUZIJIAN
3. 过滤后: liutongtong
4. 变成大写后: LIUTONGTONG

复制代码

并行流和串行流

　　在Java8中，流可以分为并行流和串行流，这两者的主要区别在于数据处理的方式。
　　Java8的stream()默认是串行流，即数据按顺序一个一个处理，可以通过parallel()方法将串行流转换为并行流，或者直接在流创建时使用parallelStream()
　　并行流底层是基于Java的ForkJoinPool实现的，这个池管理多个线程来并行处理数据，流的元素会被拆分成多个子使命并分配到不同的线程中处理，最后将效果合并。
　　并行流本身并不保证顺序。但是，在某些操作中，比如Collectors.joining()，它会保证合并效果的顺序，这通过收集器的设计来实现。
例: 并行流遍历打印

1. @Test
2. public void test() {
3.     list.parallelStream().forEach(System.out::println);
4. }

复制代码

运行效果

1. ccc
2. eee
3. ddd
4. bbb
5. aaa

复制代码

例: 并行流多线程将0加到100
LongStream.rangeClosed(0, 100000000000L)创建了从0到100000000000L之间全部整数的流，然后reduce()会先将流分成多个子流，每个子流盘算局部的和，在不同的线程中进行，每个线程分别盘算一部分和，盘算完成后，再将各个子使命盘算的效果合并，得到盘算效果932356074711512064

1. public static void main(String[] args) {
2.     long reduce = LongStream.rangeClosed(0, 100000000000L)
3.             .parallel() // 转换为并行流，底层是fork-join
4.             .reduce(0, Long::sum);
5.     System.out.println(reduce);
6. }

复制代码

以上就是Java8 StreamAPI的全部内容。
4.接口的默认方法

　　Java8前的接口，只能有两个成员，全局静态常量和抽象方法，Java8引入了接口的默认方法和静态方法作为新特性，它们的引入是为了增强接口的功能，特别是在接口的扩展性和灵活性方面。
　　接口中的默认方法，使用default修饰符修饰，可以带有实现，实现类可以直接继续使用，实现类可以选择重写默认方法，也可以直接使用。
　　接口中的静态方法只能通过接口名调用，不能通过接口的实现类或实例调用，为接口提供相关的工具性功能，而不需要依赖具体的实现类，静态方法不会被实现类继续，也不能被实现类重写。
接口的默认方法和静态方法

编写一个接口test.testinterface.MyInterface，拥有两个默认方法test()，hello()和一个静态方法helloworld()

1. package test.testinterface;
3. public interface MyInterface {
4.    
5.     default String test() {
6.         System.out.println("default");
7.         return "default";
8.     }
10.     default void hello() {
11.         System.out.println("my interface");
12.     }
13.    
14.     static void helloworld() {
15.         System.out.println("hello java8!!!");
16.     }
17. }

复制代码

编写一个类test.testinterface.SubClass，实现接口MyInterface

1. package test.testinterface;
3. public class SubClass  implements MyInterface {
5.     public static void main(String[] args) {
6.         SubClass subClass = new SubClass();
7.   
8.         subClass.hello();
10.         MyInterface.helloworld();
11.     }
12. }

复制代码

不实现接口里面的hello()方法也可以直接调用默认方法hello()，而且可以通过接口名直接调用接口的静态方法helloworld()，程序输出:

1. my interface
2. hello java8!!!

复制代码

方法辩说

编写另一个接口test.testinterface.OtherInterface，并实现一个默认方法hello

1. package test.testinterface;
3. public interface OtherInterface {
4.     default void hello() {
5.         System.out.println("other interface");
6.     }
7. }

复制代码

令类test.testinterface.SubClass再实现一个接口OtherInterface，该接口含有和接口MyInterface一样定义的default方法hello()，就产生了接口辩说，当实现的多个接口中有雷同签名的默认方法时，子类必须显式重写辩说的方法hello()，最终程序输出效果:"sub hello!"

1. package test.testinterface;
3. public class SubClass implements MyInterface, OtherInterface {
4.     /**
5.      * 多实现方法冲突，实现类必须实现
6.      **/
7.     @Override
8.     public void hello() {
9.         System.out.println("sub hello!");
10.     }
12.     public static void main(String[] args) {
13.         SubClass subClass = new SubClass();
14.         subClass.hello();
15.     }
16. }

复制代码

类优先

编写一个类test.testinterface.MyClass，里面有一个方法String test()，并让SubClass类继续它，并实行subClass.test();，得到输出效果:"class"，但是SubClass实现的接口MyInterface里面也有个方法String test()，却没有被实行，而是实行了类里面的方法，说明类优先，如果类或其父类中已经提供了方法实现，则优先使用类的实现，而不是接口的默认方法。

1. package test.testinterface;
3. public class MyClass  {
4.     public String test() {
5.         System.out.println("class");
6.         return "class";
7.     }
8. }

复制代码

1. package test.testinterface;
3. public class SubClass extends MyClass implements MyInterface, OtherInterface {
4.     // 多实现方法冲突，实现类必须实现
5.     @Override
6.     public void hello() {
7.         System.out.println("sub hello!");
8.     }
10.     public static void main(String[] args) {
11.         SubClass subClass = new SubClass();
12.         // 类优先原则， 继承类的方法
13.         subClass.test();
14.     }
15. }

复制代码

5.新的日期和时间API (java.time)

旧API的线程安全题目

　　旧的日期时间工具类java.text.SimpleDateFormat存在线程安全题目，比方SimpleDateFormat线程不安全，内部依赖一个Calendar实例来解析和格式化日期，而Calendar是线程不安全的，多线程格式化会并发更新Calendar状态会导致出现异常。
以下代码使用100个线程并发调用一个format对象进行日期解析操作，会导致出现错误。

1. package test.time;
3. import java.text.SimpleDateFormat;
5. public class Test1 {
7.     public static void main(String[] args)  {
8.         
9.         SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
11.         Runnable r = new Runnable() {
12.             @Override
13.             public void run() {
14.                 try {
15.                     System.out.println(format.parse("20191231"));
16.                 } catch (Exception e) {
17.                     throw new RuntimeException(e);
18.                 }
19.             }
20.         };
22.         for (int i=0; i<100; i++) {
23.             new Thread(r, "t"+i).start();
24.         }
26.     }
27. }

复制代码

如果值不存在，可以抛出自定义异常

1. package test.time;
3. import java.text.SimpleDateFormat;
5. public class Test1 {
7.     public static void main(String[] args)  {
8.         
9.         SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
11.         Runnable r = new Runnable() {
12.             @Override
13.             public void run() {
14.                 synchronized (format) {
15.                     try {
16.                         System.out.println(format.parse("20191231"));
17.                     } catch (Exception e) {
18.                         throw new RuntimeException(e);
19.                     }
20.                 }
22.             }
23.         };
25.         for (int i=0; i<100; i++) {
26.             new Thread(r, "t"+i).start();
27.         }
29.     }
30. }

复制代码

转换

map() 如果有值进行处理，并返回处理后的Optional对象，否则返回Optional.empty()
空值，不实行输出

1. package test.time;
3. import java.text.SimpleDateFormat;
5. public class Test1 {
7.     public static void main(String[] args)  {
9.         Runnable r = new Runnable() {
10.             @Override
11.             public void run() {
12.                 try {
13.                     System.out.println(new SimpleDateFormat("yyyyMMdd").parse("20191231"));
14.                 } catch (Exception e) {
15.                     throw new RuntimeException(e);
16.                 }
17.             }
18.         };
20.         for (int i=0; i<100; i++) {
21.             new Thread(r, "t"+i).start();
22.         }
24.     }
25. }

复制代码

非空，处理后返回新的Optional，输出：HELLO WORLD

1. package test.time;
4. import java.text.SimpleDateFormat;
5. import java.util.concurrent.ExecutorService;
6. import java.util.concurrent.Executors;
9. public class Test1 {
11.    
12.     public static void main(String[] args)  {
14.         ExecutorService executorService = Executors.newFixedThreadPool(10);
16.         ThreadLocal<SimpleDateFormat> threadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd"));
18.         Runnable runnable = new Runnable() {
19.             @Override
20.             public void run() {
21.                 try {
22.                     System.out.println(threadLocal.get().parse("20191231"));
23.                 }
24.                 catch (Exception e) {
25.                     throw new RuntimeException(e);
26.                 }
27.             }
28.         };
31.         for (int i=0; i<100; i++) {
32.             executorService.submit(runnable, "t"+i);
33.         }
35.         executorService.shutdown();
37.     }
38. }

复制代码

使用flatMap()进一步防止空指针异常，如果optional中的值为null，flatMap()直接返回Optional.empty()，否则，它返回一个包罗e.getName()的Optional对象

1. package test.time;
3. import org.junit.Test;
5. import java.time.*;
6. import java.time.format.DateTimeFormatter;
7. import java.time.format.FormatStyle;
8. import java.time.temporal.*;
9. import java.util.Date;
11. public class Test4 {
13.     /**
14.      * java8 API获取当前时间
15.      */
16.     @Test
17.     public void current() {
18.         Instant instant = Instant.now();
20.         LocalDate localDate = LocalDate.now();
22.         LocalTime localTime = LocalTime.now();
24.         LocalDateTime localDateTime = LocalDateTime.now();
26.         ZonedDateTime zonedDateTime = ZonedDateTime.now();
28.         System.out.println(instant);
29.         System.out.println(localDate);
30.         System.out.println(localTime);
31.         System.out.println(localDateTime);
32.         System.out.println(zonedDateTime);
34.     }
37.    
38.     /**
39.      * Instant的常见方法
40.      */
41.     @Test
42.     public void testInstant() {
43.         //通过Instant获取当前时间戳，格林威治时间
44.         Instant now = Instant.now();
45.         System.out.println(now);
47.         //添加时区，转换为带时区的时间：OffsetDateTime
48.         OffsetDateTime us = now.atOffset(ZoneOffset.ofHours(-4));
49.         System.out.println(us);//US
51.         //设置偏移量
52.         OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(+8));
53.         System.out.println(offsetDateTime);//CN
54.         System.out.println(now.atOffset(ZoneOffset.ofHours(+9)));//JP
55.         System.out.println(now.atOffset(ZoneOffset.ofHours(+10)));//AU
57.         //根据给定的Unix时间戳（即自1970年1月1日00:00:00 UTC起的秒数）创建一个Instant对象
58.         Instant instant = Instant.ofEpochSecond(1);//开始于1970
59.         System.out.println(instant);
61.         //设置时区
62.         ZonedDateTime zonedDateTime = now.atZone(ZoneId.of("GMT+9"));
63.         LocalDateTime localDateTime = zonedDateTime.toLocalDateTime();
64.         System.out.println(localDateTime);
65.     }
67.     /**
68.      * LocalDateTime LocalDate LocalTime 的常见方法和使用
69.      */
70.     @Test
71.     public void testLocalDateTime() {
73.         // 获取当前时间
74.         LocalDateTime now = LocalDateTime.now();
75.         System.out.println(now);
77.         //构造时间
78.         LocalDateTime localDateTime = LocalDateTime.of(2019,8,8,12,23,50);
79.         System.out.println(localDateTime);
81.         //从LocalDate和LocalTime构造时间
82.         System.out.println(LocalDateTime.of(LocalDate.now(), LocalTime.now()));
84.         // 获取年月日时分秒
85.         System.out.println(localDateTime.getYear());
86.         System.out.println(localDateTime.getDayOfYear());
87.         System.out.println(localDateTime.getDayOfMonth());
89.         //星期
90.         DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
91.         System.out.println(dayOfWeek);
93.         //当前时间的纳秒部分，表示这个时间点内的精细时间
94.         System.out.println(localDateTime.getNano());
96.         //时间计算
97.         System.out.println(LocalDateTime.now().plusMonths(2));
98.         System.out.println(LocalDateTime.now().minusYears(2));
99.         System.out.println(LocalDateTime.now().plusHours(24));
100.         System.out.println(LocalDateTime.now().plusNanos(500));
102.         System.out.println(LocalDateTime.now().plusYears(2).plusMonths(8).plusDays(9));
104.         // Period.of 用于创建一个表示特定时间间隔的Period对象
105.         System.out.println(LocalDateTime.now().plus(Period.of(3, 5, 20))); ;
107.         // ChronoUnit.DECADES代表十年
108.         System.out.println(LocalDateTime.now().plus(3, ChronoUnit.DECADES)) ;
111.         // 时间修改
112.         System.out.println(LocalDateTime.now().withMonth(2));
113.         System.out.println(LocalDateTime.now().withDayOfMonth(25));
114.         System.out.println(LocalDateTime.now().withSecond(22));
115.         System.out.println(LocalDateTime.now().with(ChronoField.DAY_OF_MONTH, 2));
116.         System.out.println(LocalDateTime.now().with(ChronoField.MONTH_OF_YEAR, 8));
118.         // LocalDate LocalTime
119.         System.out.println(LocalDate.of(2020, 1, 19));
120.         System.out.println(LocalDate.of(2020, Month.AUGUST, 19));
121.         System.out.println(LocalDate.of(2020, Month.of(12), 19));
122.         System.out.println(LocalTime.of(20, 0));
124.         System.out.println(LocalDate.now().withMonth(8));
125.         System.out.println(LocalDate.of(2020, Month.AUGUST, 19).plusDays(5));
126.         System.out.println(LocalDate.of(2020, Month.of(12), 19));
129.         System.out.println( LocalTime.of(20, 0).plusHours(8) );
131.         // LocalDate的方法，判断当前年份是否为闰年
132.         System.out.println(LocalDate.now().isLeapYear());
134.     }
136.     /**
137.      * TemporalAdjusters 时间校正器
138.      */
139.     @Test
140.     public void testTemporalAdjusters() {
141.         // 下一个周四
142.         LocalDateTime dateTime = LocalDateTime.now();
144.         dateTime.with(TemporalAdjusters.next(DayOfWeek.THURSDAY));
145.         System.out.println(dateTime);
147.         dateTime.with(TemporalAdjusters.previous(DayOfWeek.THURSDAY));
148.         System.out.println(dateTime);
150.         dateTime.with(TemporalAdjusters.nextOrSame(DayOfWeek.THURSDAY));
151.         System.out.println(dateTime);
153.         dateTime.with(TemporalAdjusters.previousOrSame(DayOfWeek.THURSDAY));
154.         System.out.println(dateTime);
156.         System.out.println(LocalDate.now().with(TemporalAdjusters.nextOrSame(DayOfWeek.SATURDAY)));
158.         // 获取月份第一天
159.         System.out.println(LocalDate.now().with(TemporalAdjusters.firstDayOfMonth()));
162.         System.out.println(LocalDate.now().with(TemporalAdjusters.firstDayOfNextMonth()));
164.         // 自定义 计算下一个工作日
165.         LocalDateTime nextWorkDay = LocalDateTime.now().with((e) -> {
166.             LocalDateTime temp = LocalDateTime.from(e);
167.             DayOfWeek dayOfWeek = temp.getDayOfWeek();
168.             if (dayOfWeek.equals(DayOfWeek.FRIDAY)) {
169.                 return temp.plusDays(3);
170.             } else if (dayOfWeek.equals(DayOfWeek.SATURDAY)) {
171.                 return temp.plusDays(2);
172.             } else {
173.                 return temp.plusDays(1);
174.             }
175.         });
177.         System.out.println(nextWorkDay);
178.     }
182.     public void test() {
183.         System.out.println(Year.now());
184.         System.out.println(YearMonth.now());
185.         System.out.println(MonthDay.now());
186.     }
189.     /**
190.      * 计算时间间隔：武汉封了多少天，多少小时
191.      */
192.     @Test
193.     public void testChronoUnit() {
195.         LocalDateTime from = LocalDateTime.of(2020, Month.JANUARY, 23, 10, 0,0);
196.         LocalDateTime to = LocalDateTime.of(2020, Month.APRIL, 8, 0, 0,0);
198.         long days = ChronoUnit.DAYS.between(from, to);
199.         long hours = ChronoUnit.HOURS.between(from, to);
201.         System.out.println( days );
202.         System.out.println( hours );
203.     }
206.     /**
207.      * 使用 TemporalQuery 来计算当前时间与一个指定时间点（2020年1月19日10:00:00）之间的小时差，
208.      * 并将其作为 long 类型的值返回
209.      */
210.     @Test
211.     public void testTemporalQuery() {
212.         long l = LocalDateTime.now().query(new TemporalQuery<Long>() {
214.             @Override
215.             public Long queryFrom(TemporalAccessor temporal) {
216.                 LocalDateTime now = LocalDateTime.from(temporal);
217.                 LocalDateTime from = LocalDateTime.of(2020, Month.JANUARY, 19, 10, 0,0);
218.                 return ChronoUnit.HOURS.between(from, now);
219.             }
220.         });
222.         System.out.println(l);
223.     }
226.     /**
227.      * Duration类，只能计算时间差异
228.      */
229.     @Test
230.     public void testDurationPeriod() {
231.         LocalTime start = LocalTime.of(20, 0);
232.         LocalTime end = LocalTime.of(21, 30);
234.         // 时间间隔
235.         Duration between = Duration.between(start, end);
236.         System.out.println(between.toHours());
237.         System.out.println(between.toMinutes());
239.     }
242.     /**
243.      * 格式化 DateTimeFormatter
244.      */
245.     @Test
246.     public void testDateTimeFormatter() {
248.         DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME;
249.         System.out.println(LocalDateTime.now().format(formatter));
251.         LocalDate localDate = LocalDate.parse("2009-12-31", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
252.         System.out.println(localDate);
254.         LocalDateTime localDateTime = LocalDateTime.parse("2009-12-31 01:01:02", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
255.         System.out.println(localDateTime);
257.         // 2024年12月1日 星期日
258.         System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)));
260.         // 2024年12月1日
261.         System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG)));
263.         // 24-12-1
264.         System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)));
266.         // 2024-12-1
267.         System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)));
268.     }
271.     @Test
272.     public void getAvailableZoneIds() {
273.         // 当前系统时区
274.         System.out.println(ZoneId.systemDefault());
276.         // 打印java8中所有支持时区
277.         ZoneId.getAvailableZoneIds().forEach(System.out::println);
278.     }
281.     /**
282.      * OffsetDateTime
283.      */
284.     @Test
285.     public void testOffsetDateTime() {
286.         OffsetDateTime offsetDateTime = new Date().toInstant().atOffset(ZoneOffset.of("-4"));
287.         System.out.println(offsetDateTime);
288.         System.out.println(offsetDateTime.toLocalDateTime());
290.         OffsetDateTime of = OffsetDateTime.of(LocalDateTime.now(), ZoneOffset.of("-4"));
291.         System.out.println(of);
293.     }
295.     /**
296.      * ZonedDateTime
297.      */
298.     @Test
299.     public void testZonedDateTime() {
300.         // 当前时间转换为东京时间是几时
301.         ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
302.         System.out.println(zonedDateTime);
303.         System.out.println(zonedDateTime.toLocalDateTime());
305.         ZonedDateTime of = ZonedDateTime.of(LocalDateTime.now(), ZoneId.of("Asia/Tokyo"));
306.         System.out.println(of);
308.         // 为当前时间带上时区
309.         ZonedDateTime tokyo = LocalDateTime.now().atZone(ZoneId.of("Asia/Tokyo"));
310.         System.out.println(tokyo);
311.         System.out.println(tokyo.toLocalDateTime());
313.         // 将一个时区时间转换为同一时刻另一个时区时间
314.         ZonedDateTime beijing = tokyo.withZoneSameInstant(ZoneId.of("GMT+8"));
315.         System.out.println(beijing);
317.         ZonedDateTime usa = LocalDateTime.now()
318.                 .atZone(ZoneId.systemDefault())
319.                 .withZoneSameInstant(ZoneId.of("GMT-4"));
321.         System.out.println(usa);
323.     }
325. }

复制代码

7.重复注解 (Repeating Annotations)

1.首先创建一个容器注解，这个注解范例包罗一个注解数组，存储多个雷同范例的注解

1. package test.time;
3. import org.junit.Test;
5. import java.sql.Timestamp;
6. import java.time.*;
7. import java.util.Calendar;
8. import java.util.Date;
10. public class Test5 {
12.     /**
13.      * 将 LocalDateTime 和系统默认时区结合，转换为 ZonedDateTime
14.      * 再将 ZonedDateTime 转换为 Instant，这是一个包含 UTC 时间戳的对象。
15.      * Date.from()：将 Instant 转换为 java.util.Date 对象
16.      */
17.     @Test
18.     public void toDate() {
19.         LocalDateTime localDateTime = LocalDateTime.now();
20.         Instant instant = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
21.         Date date = Date.from(instant);
22.         System.out.println(date);
23.     }
26.     @Test
27.     public void toLocalDateTime() {
28.         Date date = new Date();
29.         LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
30.         System.out.println(dateTime);
32.     }
35.     /**
36.      * java.sql.Date 转换 LocalDateTime
37.      */
38.     @Test
39.     public void sqlDate() {
40.         java.sql.Date date = new java.sql.Date(System.currentTimeMillis());
41.         LocalDate localDate = date.toLocalDate();
42.         System.out.println(localDate);
44.         Timestamp timestamp = new Timestamp(System.currentTimeMillis());
45.         LocalDateTime localDateTime = timestamp.toLocalDateTime();
46.         System.out.println(localDateTime);
48.     }
50.     /**
51.      * Calendar 转换 LocalDateTime
52.      */
53.     @Test
54.     public void calendarToLocalDateTime() {
55.         Calendar calendar = Calendar.getInstance();
56.         ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(calendar.toInstant(), calendar.getTimeZone().toZoneId());
57.         System.out.println(zonedDateTime.toLocalDateTime());
59.     }
61. }

复制代码

2.定义一个重复注解，并使用@Repeatable标记

1. Optional<String> optional = Optional.of("Hello, World!");

复制代码

3.测试，通过反射访问方法上的注解，由于MyAnnotation是重复注解，所以一个方法加上多个也不会语法报错，然后提取此中的多个MyAnnotation注解。

1. Optional<String> optional = Optional.ofNullable(null);

复制代码

8.Nashorn JavaScript引擎

这个不常用，未完待续

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。