java8新特性整理

女爷i 2022-06-01 10:49 165阅读 0赞

本文转载自博客：[http://blog.csdn.net/54powerman/article/details/73188951][http_blog.csdn.net_54powerman_article_details_73188951]

ava9快来了，必须得梳理一下java8了。

官方文档：[http://docs.oracle.com/javase/specs/jls/se8/html/index.html][http_docs.oracle.com_javase_specs_jls_se8_html_index.html]

## 一、接口的默认方法和静态方法 ##

接口里也可以写方法体了，实现该接口的类不再强制实现该方法，只需要在方法签名增加default签名并实现方法体，如：

接口：

public interface Compute { 
        default Integer add(Integer x,Integer y) {
            return x+y;
        }
        Integer minus(Integer x,Integer y);
    }
     
      
       1
       2
       3
       4
       5
       6

实现：

public class ComputeImpl implements Compute { 
    
        @Override
        public Integer minus(Integer x, Integer y) {
            return x-y;
        }
    
        public static void main(String[] args) {
            ComputeImpl c=new ComputeImpl();
            System.out.println(c.add(2, 1));
            System.out.println(c.minus(22, 1));
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13

接口可以定义静态方法，通过接口调用。实现类不需实现，也无法在实现类中直接调用。

public interface Compute { 
        default Integer add(Integer x,Integer y) {
            return x+y;
        }
        Integer minus(Integer x,Integer y);
    
        static void test() {
            System.out.println("static method test()");
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

调用时：

Compute.test();
     
      
       1

注意：缺省方法或静态方法引入，让java拥有了C++类似的多重继承的能力，所以同样会存在继承导致的歧义。

## 二、内部类访问外部变量 ##

java7及以前，在内部类中访问外部变量，需要外部变量定义为final。java8中final关键字不是必须的了，但是需要确保不会修改该变量，否则仍旧会编译错误。

对于外部来的静态成员和字段，可以任意访问。

lambda中同内部类相同。

## 三、Lambda 表达式 ##

### 3.1) 什么是lambda ###

[http://www.importnew.com/8118.html][http_www.importnew.com_8118.html]

#### ① 格式 ####

lambda是一个语法糖，编写代码时可以提高编码效率，实际编译后的结果是一样的。形如：

(Class1 p1,Class2 p2...pn) -> {
      statement1；
      statement2；
      //...
      statementn;
    }
     
      
       1
       2
       3
       4
       5
       6

它相当于jdk7及以前的内部类：

new Interface1(){
      @Override
      public Class1 abstractMethod(Class1 p1,Class2 p2...pn){
        statement1；
        statement2；
        //...
        statementn;
      }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9

#### ② lambda格式说明： ####

(Class1 p1,Class2 p2…pn) 为lambda头，或称为参数列表，即接口中方法的参数列表。

\-> 为 lambda运算符。

\{statementn…；\} 为 lambda体，即接口中方法实现的代码块。

#### ③ lambda代码简化规则 ####

由于jdk在编译时会有代码检查，java8 针对lambda增强了代码检查时的推测能力，他可以根据上下文对变量类型、代码块关键字进行一些推断，因此提供了lambda简化的能力。

*  参数列表中的变量类型可以省略，jdk会根据接口中的参数进行匹配。
 *  如果参数只有一个，参数列表的括号可以省略。
 *  如果方法体中的语句只有一行，那么大括号和分号可以省略。需要注意，如果方法体有返回值，return关键字也一起省略。

#### ④ lambda和内部类的区别 ####

除了精简了代码之外，lambda中如果引用this，那么this指针是包装类，即lambda被调用的类；而内部类中，则是指内部类。

### 3.2) 函数式接口 ###

要用lambda形式使用接口，需要接口为一种特殊的接口类型，即函数式接口。所谓函数接口，是只有一个抽象方法的接口。

所谓函数式接口中的抽象方法，并不是抽象类中的抽象方法，它不需要abstract关键修饰，是指jdk7及以前的没有方法体的方法。

函数式接口中除了唯一的未实现方法之外，可以有其他有函数体的default方法。

只要符合以前上条件，就是一个合法的函数式接口。java8中提供了一个注解`@FunctionalInterface`，将它标注在接口定义上面，可以在编译阶段校验，如果接口中定义了第二个抽象方法会编译失败。该注解不是必需的。

@FunctionalInterface
    public interface Compute { 
        default Integer add(Integer x,Integer y) {
            return x+y;
        }
        Integer minus(Integer x,Integer y);
    }
     
      
       1
       2
       3
       4
       5
       6
       7

### 3.3) 测试lambda ###

#### ① 无参无返回值 ####

接口定义：

public interface ICompute { 
        public void print();
    }
     
      
       1
       2
       3

定义使用该接口的方法：

private void hello(ICompute c){
      c.print();
    }
     
      
       1
       2
       3

测试用例1——传统内部类方式

@Test
        public void testAnonymousInnerClass(){
            int i=12;
            hello(new ICompute() {
    
                @Override
                public void print() {
                    System.out.println(i);//jdk7会报错，要求i为final；java8则不报错，假定你不会修改，如果修改就会报错
                    System.out.println("Hello anonymous inner class.");
                }
            });
        }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12

测试用例2——lambda

hello(()-> System.out.println("Hello lambda"));
     
      
       1

#### ② 有参无返回值 ####

接口定义：

public interface FunctionalInterfaceVoidArg { 
        public void sayHi(String str);
    }
     
      
       1
       2
       3

定义使用该接口的方法：

private void sayHi(String str,FunctionalInterfaceVoidArg object) {
      object.sayHi(str);
    }
     
      
       1
       2
       3

测试用例：

@Test
    public void testLambdaVoidHasArg(){
      sayHi("peter",x-> System.out.println("Hello "+x));
    }
     
      
       1
       2
       3
       4

#### ② 有返回值 ####

接口定义：

public interface FunctionalInterfaceReturn { 
        public String generateTime();
    }
     
      
       1
       2
       3

定义使用该接口的方法：

private String getTime(FunctionalInterfaceReturn fi){
      return fi.generateTime();
    }
     
      
       1
       2
       3

测试用例：

@Test
    public void testLambdaReturn(){
      String str=getTime(()->{
        return String.valueOf(System.currentTimeMillis());
      });
      System.out.println(str);
    
      //省略大括号和分号的简化lambda
      str=getTime(()->new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
      System.out.println(str);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11

### 3.4) java8内置的特定函数式接口 ###

① Predicate

接收一个参数，返回一个boolen值，用于条件判断。

//使用lambda
    Predicate<String> pre=(x)-> x.startsWith("t_");
    boolean isTable=pre.startsWith("t_users");
    //使用方法引用
    Predicate<Boolean> notNull=Objects::nonNull;
    Predicate<Boolean> isNull=Objects::isNull;
    
    Predicate<Sting> isEmpty=String::isEmpty;
    Predicate<String> notEmpty=isEmpty.negate();
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9

② Comparator

这是一个早已存在的接口，在java8中实现了一些默认方法。

### 3.5) java8内置的通用函数式接口 ###

#### ① Supplier ####

package java.util.function;
    @FunctionalInterface
    public interface Supplier<T>{ 
      T get();
    }
     
      
       1
       2
       3
       4
       5

适用于无入参，有返回值的场景。如生产者。

典型的应用是List.forEach(Supplier s);

Arrays.asList("aa","bb","cc").forEach((x)->System.out.println(x));
     
      
       1

#### ② Consumer ####

package java.util.function;
    
    @FunctionalInterface
    public interface Consumer<T> { 
      void accept(T t);
    }
     
      
       1
       2
       3
       4
       5
       6

适用于有一个入参，无返回值的场景。如消费者。

#### ③ Function ####

package java.util.function;
    @FunctionalInterface
    public interface Function<T, R> { 
      R apply(T t);
    }
     
      
       1
       2
       3
       4
       5

适用于一个类型的入参，返回一个类型的场景。

#### ④ UnaryOperator ####

package java.util.function;
    @FunctionalInterface
    public interface UnaryOperator<T> extends Function<T, T> { 
      static <T> UnaryOperator<T> identity() {
        return t -> t;
      }
    }
     
      
       1
       2
       3
       4
       5
       6
       7

事实上，他就是`Function<T,R>`的一种特殊情况，即`Function<T,T>`。

#### ⑤ Predicate ####

package java.util.function;
    @FunctionalInterface
    public interface Predicate<T>{ 
      boolean test(T t);
    }
     
      
       1
       2
       3
       4
       5

它类似于`Function<T, Boolean>`，但并未继承Function，用于条件判断，类似于guava中的Predicate。

#### ⑥ 其他类型 ####

java8在包`java.util.function` 中提供了很多类型，如果不能满足可以查看javadocs，查找合适的类型，或自定义。

## 四、方法引用 ##

在需要函数参数的方法中，我们可以把另一个同类型的方法直接传入，这称为方法引用的绑定。类似于C语言中的函数指针。

lambda表达式可以替代方法引用；或者说方法引用是lambda的一种特例，方法引用不可以控制传递参数。

### 4.1) 构造器引用 ###

private Person construntorRef(Supplier<Person> sup){
        Person p=sup.get();
        return p;
    }
    
    @Test
    public void testConstructorRef(){
        Person p=construntorRef(Person::new);
        System.out.println(p);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

需要有无参的构造器。

### 4.2） 静态方法引用 ###

private static void print(String s){
            System.out.println(s);
        }
    
        @Test
        public void testStaticRef(){
            Arrays.asList("aa","bb","cc").forEach(TestMethodReference::print);
        }
     
      
       1
       2
       3
       4
       5
       6
       7
       8

so easy，只要静态方法的参数列表和FI需要的参数一致就可以。

### 4.3) 成员方法引用 ###

@Test
        public void testMemberMethodRef(){
            Arrays.asList("aa","bb","cc").forEach(System.out::println);
        }
     
      
       1
       2
       3
       4

so easy，只要成员方法的参数列表和FI需要的参数一致就可以。

### 4.4) 类的任意对象的实例方法引用(很怪异) ###

@Test
    public void testClassMemberMethodRef(){
        String[] strs={
       "zzaa","xxbb","yycc"};
        Arrays.sort(strs,String::compareToIgnoreCase);//OK
        System.out.println(Arrays.asList(strs));
        File[] files = new File("C:").listFiles(File::isHidden); // OK
    }
     
      
       1
       2
       3
       4
       5
       6
       7

��，前方高能，请关掉耳机的音乐，认真思考，小心行事。

传统的java开发中，是不允许使用类名去调用成员方法的，这是一个基本原则，那么这里的这种写法就有点不太容易理解了。还是用实例说明：

用到的内部类：

import lombok.Data;
    
    @Data
    public static class Person{ 
        private String name;
        private Integer age;
    
        public int mycompare(Person p1){
            return p1.getAge()-this.getAge();
        }
        public void print(){
            System.out.println(this);
        }
    
        public void println(Person p){
            System.out.println(p);
        }
    
        public int compareByAge(Person a,Person b){
            return a.getAge().compareTo(b.getAge());
        }
    }
    
    public static class APerson{ 
        public void print(){
            System.out.println(this);
        }
    
        public void println(Person p){
            System.out.println(p);
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32

测试代码：

@Test
        public void testClassMemberMethodRef2() {
            // R apply(T t);//要求一个参数
            Function<String, String> upperfier1 = String::toUpperCase;
            UnaryOperator<String> upperfier2 = (x) -> x.toUpperCase();//这里没有参数，即0个
    
            /* * 小结：如果方法引用表达式 "String::toUpperCase" 可以用lambda表达式中参数的指定成员方法(这个成员方法的参数比FI要求的参数少一个改类型的参数)改写， * 那么就可以使用 "类的实例方法"来表示方法引用。 * * 或者说：如果lambda表达式的lambda体中使用的方法是参数匹配的方法，那么方法引用表达式就用"类引用对象的实例方法"。 * * lambda的参数是方法的主体。 */
    
    
            class Print {
                public void println(String s) {
                    System.out.println(s);
                }
            }
            // void accept(T t);
    
            Consumer<String> sysout1 = new Print()::println;
            Consumer<String> sysout2 = (x) -> new Print().println(x);
    
            /* * 小结：如果方法引用表达式 "new Print()::println" 可以用lambda表达式中参数的具体对象的参数匹配的成员方法改写， * 那么就用 "对象的实例方法"来表示方法引用。 * * 或者说：如果lambda表达式的lambda体中使用的方法来操作lambda的参数，那么方法引用表达式就用"对象的实例方法"。 * * lambda的参数是方法的参数。 */
    
            //有一个更让人易混淆的例子，可以用上面的规则来验证，Arrays.sort(T t,Comparator<? extends t> c)
    
            class Person {
                public int com1(Person p) {
                    return 1;
                }
    
                public int com2(Person p1, Person p2) {
                    return 1;
                }
            }
    
            // int compare(T o1, T o2);//需要两个参数
    
            Person【】 ps = { new Person(), new Person() };
            Arrays.sort(ps, Person::com1);
            Arrays.sort(ps, (x,y)->x.com1(y));
    
            Arrays.sort(ps, new Person()::com2);
            Arrays.sort(ps, (x,y)->new Person().com2(x, y));
    
            //按照以上规则验证应该能说明清楚。
    
            /* * 但是一个接口为什么有两种写法？缺省的lambda会匹配FI方法，即"int compare(T o1, T o2);" * 从上面的lambda表达式来分析，默认的使用lambda应该是： */
    
            Comparator<Person> comparator1 = new Person()::com2;
    
            /* * 下面的方式又是怎么回事呢？ */
            Comparator<Person> comparator2 = Person::com1;
            System.out.println(comparator2);
    
            /* * 任一个两个参数的FI接口方法（int compare(T o1, T o2)），都可以用引用减少一个参数的方法（int o1<T>.compare(T o2)）来代替，而引用对象本身作为另一个隐含参数，那么方法引用的对象用类名，表示类的任意对象。 还是有点乱？我们来换一个角度来看一下： 首先，我们需要的是int compare(T o1, T o2)是两个参数； 其次，先不考虑::前缀是类还是对象，你给了我一个compare(T o2)，少一个参数？怎么办？ lambda机制为了解决这个问题，它使用::前面的类名new一个对象，当做需要的缺少的那个参数，这就是类的实例方法。 */
        }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80

小结一下：

首先明确此处需要的方法参数列表，此处标记参数个数为N，那么：
    
    1. 如果传入的方法是一个类型的静态方法，而且参数匹配，使用“类的静态方法引用”；这应该不难理解。
    
    2. 如果传入的方法是一个实例的成员方法，而且参数匹配，使用“实例的成员方法”；这也应该不难理解。
    
    3. 如果传入的方法是一个类型T的实例的成员方法，而且参数为N-1个，缺少了一个T类型的参数，那么就使用“T类型的实例方法”。
     
      
       1
       2
       3
       4
       5
       6
       7

#### 烧脑分析类的实例方法省略了哪个参数 ####

前面的例子，FI的两个参数是同一个类型，如果类型不同呢？省略了哪个参数呢？

是按照位置省略了第一个，亦或者是省略了最后一个？

还是按照类型自动去对应，而不关心第几个呢？

这个时候，我们能想到的办法可能是去看源码，但是一般看代码没有个把礼拜甚至更长，毛都看不出来。我们还是用一个例子来分析一下吧。

定义一个FI接口：

package com.pollyduan.fi;
    
    public interface TestInterface { 
        //随便什么名字，lambda并不关心，因为FI只有一个接口，并且根据参数来匹配
        public void anyStringAsName(TestBean1 bean1,TestBean2 bean2);
    }
     
      
       1
       2
       3
       4
       5
       6

编写两个用于参数的类：

TestBean1.java

package com.pollyduan.fi;
    
    public class TestBean1 { 
        public void expect1(TestBean1 bean1){
    
        }
        public void expect2(TestBean2 bean2){
    
        }
        public void test1(TestInterface i){
    
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13

TestBean2.java

package com.pollyduan.fi;
    
    public class TestBean2 { 
        public void expect1(TestBean1 bean1){
    
        }
        public void expect2(TestBean2 bean2){
    
        }
        public void test1(TestInterface i){
    
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13

二者区别不大。

编写测试类：

package com.pollyduan.fi;
    
    public class TestFIMain { 
        public static void main(String[] args) {
            TestBean1 bean1=new TestBean1();
            bean1.test1(TestBean1::expect1);//①
            bean1.test1(TestBean1::expect2);//② ok
            bean1.test1(TestBean2::expect1);//③
            bean1.test1(TestBean2::expect2);//④
    
            TestBean2 bean2=new TestBean2();
            bean2.test1(TestBean1::expect1);//⑤
            bean2.test1(TestBean1::expect2);//⑥ ok
            bean2.test1(TestBean2::expect1);//⑦
            bean2.test1(TestBean2::expect2);//⑧
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17

测试方法中，除了标记OK的行正确，其他都报错。

分析：

首先我们要明确FI需要的参数列表是：(TestBean1,TestBean2)

1.  我们先看①行，我们传入的”::”前导的类是TestBean1，而expect1方法匹配的是TestBean1类型的入参bean1，也就是说省略了TestBean2类型的参数bean2，FI中的最后一个参数。即便我们使用类TestBean1去new一个对象，也找不到TestBean2,因此这个错误。
2.  我们先看②行，我们传入的”::”前导的类是TestBean1，而expect2方法匹配的是TestBean2类型的入参bean2，也就是说省略了TestBean1类型的参数bean1，那么lambda就可以使用”::”前导的TestBean1构建一个对象，作为第一个参数，从而匹配FI的接口方法。ok。
3.  我们先看③行，我们传入的”::”前导的类是TestBean2，而expect1方法匹配的是TestBean1类型的入参bean1，也就是说省略了TestBean2类型的参数bean2，FI的最后一个参数。按照第二步的分析，我们用”::”前导的类TestBean2去new一个对象，应该可以凑足两个参数。实际测试会发现这不灵。这就证明了只能省略第一个参数，而且，用”::”前导的类也必须是第一个参数的类型。
4.  同第一步类似，第④行代码，找不到TestBean1的参数，有错误可以理解。
5.  至于⑤~⑧，只是替换了外层的test1的主体，没有任何区别。这证明了，lambda的匹配与外层是什么鬼没有任何关系，它只关心外层需要的FI的参数列表。
6.  请不要看下一步，在这里停下来冷静的思考一下，如果我们把TestInterface中FI方法的参数位置换一下，即`public void anyStringAsName(TestBean2 cat,TestBean1 dog);`，结果应该是哪两行正确呢？认真思考一下，实在想不明白跑一下测试用例，也许对理解更有帮助。
7.  如果想明白了用这个思路验证一下：参照参数列表`(TestBean2,TestBean1)`，可以确定只可以省略第一个参数即TestBean2，那么”::”前导类必须是TestBean2，用于自动创建对象；而未省略的参数是TestBean1,那么方法名为expect1，结果为`xxx(TestBean2::expect1)`,即③和⑦，你答对了吗？

## 五、容器功能增强 ##

### 5.1) Collection ###

List<String> list = Arrays.asList(new String[] { "xxx", "aaa", "zzz", "eee", "yyy", "ccc" });
     
      
       1

#### stream()与parallelStream() ####

##### 打开流 #####

Stream<String> stream1 = list.stream();
    Stream<String> stream2 = list.stream().parallel();
     
      
       1
       2

Stream类有几个工厂方法可以创建Stream：

Stream<Object> stream3 = Stream.builder().add(list).build();
    
    Stream<Object> stream4 = Stream.empty();
    
    Stream<String> stream5 = Stream.of("111");
    
    Stream<String> stream6 = Stream.of("111","222","333");
    
    ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(20);
    queue.addAll(list);
    Stream<String> stream7 = Stream.generate(()->{
    try {
        return queue.take();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return null;
    });
    stream7.forEach(System.out::println);
    
    Stream<String> stream8 = Stream.concat(list.stream(), list.stream());
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21

事实上我们很少直接操作Stream对象，而是作为中间结果，最终要关闭流返回数据。

##### 关闭流 #####

查看Stream实现，其中返回非Stream对象的方法，即为关闭流返回数据的方法。

Object[] toArray();
    
    <A> A[] toArray(IntFunction<A[]> generator);
    
    T reduce(T identity, BinaryOperator<T> accumulator);
    
    Optional<T> reduce(BinaryOperator<T> accumulator);
    
    <U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);
    
    <R> R collect(Supplier<R> supplier,BiConsumer<R, ? super T> accumulator,BiConsumer<R, R> combiner);
    
    <R, A> R collect(Collector<? super T, A, R> collector);
    
    Optional<T> min(Comparator<? super T> comparator);
    
    Optional<T> max(Comparator<? super T> comparator);
    
    long count();
    
    boolean anyMatch(Predicate<? super T> predicate);
    
    boolean allMatch(Predicate<? super T> predicate);
    
    boolean noneMatch(Predicate<? super T> predicate);
    
    Optional<T> findFirst();
    
    Optional<T> findAny();
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29

Stream对象打开后，关闭前，是我们要对数据做处理的主要途径。

##### collect() #####

将流转换成List。

@Test
    public void testStreamToList() {
        List<String> list1 = list.stream().collect(Collectors.toList());
    }
     
      
       1
       2
       3
       4

##### sort #####

@Test
    public void testStreamSort() {
        System.out.println(list);
        // list.sort((x, y) -> x.compareTo(y));
        List<String> list2 = list.stream().parallel()
                .sorted(Comparator.comparing(String::toLowerCase))
                .collect(Collectors.toList());
        System.out.println(list2);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9

##### filter #####

@Test
    public void testStreamFilter() {
        System.out.println(list);
        List<String> list2 = list.stream()
                .filter(x->!x.equals("zzz"))
                .collect(Collectors.toList());
        System.out.println(list2);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8

##### map #####

转换大小写

List<String> list...;
    list.stream().map(String::toUpperCase).forEach(System.out::println);
     
      
       1
       2

提取局部信息：

Field[] fields = entityClass.getDeclaredFields();
    String fieldNames = Arrays.asList(fields).stream().map(x -> x.getName()).collect(Collectors.joining(","));
     
      
       1
       2

提取局部信息到到Map

Map<String, Integer> peoples = persons.stream().collect(Collectors.toMap(Person::getName, Person::getAge));
     
      
       1

#### forEach() ####

list.forEach(x->System.out.println(x));
    
    list.forEach(System.out::println);
     
      
       1
       2
       3

#### reduce() ####

一个参数：

@Test
    public void testStreamReduce1() {
        System.out.println(list);
        BinaryOperator<String> accumulator=BinaryOperator.maxBy((x,y)->x.compareTo(y));
        Optional<String> max = list.stream()
                .reduce(accumulator);
        System.out.println(max);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8

两个参数：

@Test
    public void testStreamReduce2() {
        System.out.println(list);
        Optional<String> max = list.stream()
                .reduce((x,y)->x+y);
        System.out.println(max);
    }
     
      
       1
       2
       3
       4
       5
       6
       7

三个参数：

@Test
    public void testStreamReduce3() {
        System.out.println(list);
        StringBuilder joining = list.stream()
                .reduce(new StringBuilder(),
                        (x, e) -> x.append(e).append(","),
                        (u, t) -> u.append(t)
                );
        System.out.println(joining);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

参数1：返回的类型，此处传入一个初始对象；   
参数2：一个Funcion(x,e)，x为处理的数据中间结果，e为当前元素。   
参数3：同2。

这个例子有点复杂，打点日志分析一下：

@Test
    public void testStreamReduce3A() {
        System.out.println(list);
        StringBuilder joining = list.stream()
                .reduce(new StringBuilder(),
                        (x, e) -> {
                            System.out.println("2:t="+x+"; u="+e);
                            x.append(",").append(e);
                            return x;
                        },
                        (x, e) -> {
                            System.out.println("3:t="+x+"; u="+e);
                            //x.append(",").append(e);
                            return x;
                        }
                );
        System.out.println(joining);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18

你会发现第三个FI并没有执行。stream加上`.parallel()`，并行处理，就看到第三个FI执行了。但是结果有点意外，乱了。

list中有6个元素，2打印6次正常；而3只打印5次。而且每运行一次，3的打印结果都是变化的。

2:t=; u=ccc
    2:t=; u=eee
    2:t=; u=aaa
    2:t=; u=xxx
    2:t=,ccc,eee,aaa; u=zzz
    2:t=,ccc; u=yyy
    3:t=,ccc,eee,aaa,xxx,zzz,yyy; u=,ccc,eee,aaa,xxx,zzz,yyy
    3:t=,ccc,eee,aaa,xxx,zzz,yyy; u=,ccc,eee,aaa,xxx,zzz,yyy
    3:t=,ccc,eee,aaa,xxx,zzz; u=,ccc,eee,aaa,xxx,zzz,yyy
    3:t=,ccc,eee,aaa,xxx,zzz,yyy; u=,ccc,eee,aaa,xxx,zzz,yyy
    3:t=,ccc,eee,aaa,xxx,zzz,yyy; u=,ccc,eee,aaa,xxx,zzz,yyy
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11

#### count() ####

@Test
    public void testStreamCount() {
         long count = list.stream().count();
        System.out.println(count);
    }
     
      
       1
       2
       3
       4
       5

#### distinct() ####

@Test
    public void testStreamDistinct() {
        List<String> list2 = list.stream().distinct().collect(Collectors.toList());
        System.out.println(list2);
    }
     
      
       1
       2
       3
       4
       5

#### allMatch/anyMatch/noneMatch ####

@Test
    public void testStreamAllMatch() {
        boolean b = list.stream().allMatch(x->x.matches("a*"));
        System.out.println("AllMath:"+b);
        b = list.stream().anyMatch(x->x.matches("a*"));
        System.out.println("anyMatch:"+b);
        b = list.stream().noneMatch(x->x.matches("a*"));
        System.out.println("noneMatch:"+b);
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9

### 5.2）Map ###

Map不支持stream(),不过java8也为它增加了附加检查的方法，如:   
putIfAbsent()   
computeIfPresent()   
getOrDefault()   
merge()

#### forEach ####

Map<String,String> map=...;
    map.forEach((key,value)->System.out.pritnln("key="+key+";value="+value))
     
      
       1
       2

### 5.3) Optional ###

## 六、Date Time API ##

java8 的 Date Time API来自jsr310([https://jcp.org/en/jsr/detail?id=310][https_jcp.org_en_jsr_detail_id_310])，这个specification的主导者中jota-time的作者Stephen Colebourne就是四分之一。

除了改为线程安全，基本上很大程度上延续了java自己的设计风格。而joda-time一些很方便的特性，如Property、toString(fmt) 都没有引入。

LocalDateTime 与Calendar相比改变有限   
LocalDate 抄过来的   
LocalTime 抄过来的   
Instance 抄过来的   
DateTimeFormatter 节操，还不如SimpleDateFormat，你怎么不去屎？   
`int LocalDateTime.getDayOfMonth()`和`DayOfWeek dateTime.getDayOfWeek()`什么玩意儿？

@Test
        public void testClock(){
            Clock clock = null;
    
            clock=Clock.system(ZoneId.of("Europe/Paris"));
            System.out.println(clock.millis());
    
            clock=Clock.systemDefaultZone();
            long millis = clock.millis();
            System.out.println(millis);
    
            System.out.println(System.currentTimeMillis());
    
            Instant instant = clock.instant();
            Date legacyDate = Date.from(instant);
            System.out.println(legacyDate.getTime());
        }
    
        @Test
        public void testTimezone(){
            System.out.println(ZoneId.getAvailableZoneIds());
            ZoneId zone1 = ZoneId.of("Europe/Berlin");
            System.out.println(zone1.getRules());
    
            ZoneId zone2=ZoneId.of("Asia/Shanghai");
            System.out.println(zone2.getRules());
        }
    
        @Test
        public void testLocalDate(){
            //LocalDate是不可变的
            LocalDate today = LocalDate.now();
            System.out.println(today);
    
            LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
    
            DayOfWeek dayOfWeek = tomorrow.getDayOfWeek();
            System.out.println(dayOfWeek);
            System.out.println(dayOfWeek.getValue());
        }
    
        @Test
        public void testLocalTime(){
            LocalTime now1 = LocalTime.now();
            System.out.println(now1);
            LocalTime now2=now1.plusMinutes(10);
            System.out.println(now2);
            LocalTime now3=now1.plus(2, ChronoUnit.HOURS);
            System.out.println(now3);
        }
    
        @Test
        public void testLocalDateTime(){
            LocalDateTime dateTime=LocalDateTime.now();
            System.out.println(dateTime);
            dateTime=LocalDateTime.of(2017, 2, 22, 13, 23);
            System.out.println(dateTime);
        }
    
        @Test
        public void testFormater(){
            //DateTimeFormatter是线程安全的，SimpleDateFormat不是
            LocalDateTime dateTime=LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            System.out.println(formatter.format(dateTime));
        }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66

欣赏一下joda-time：

System.out.println(DateTime.now().toString("yyyy-MM-dd HH:mm:ss"));
    //2017-02-21 18:26:49
    
    //计算两个时间时间隔了多少天
    DateTime dateTime=new DateTime(2008,12,8,0,0);
    Duration duration=new Duration(dateTime,DateTime.now());
    System.out.println(duration.getStandardDays());
    
    //Interval可以获得两个时间每个单位的时间差
    DateTime dt1 = new DateTime(2008, 12, 8, 8, 31);
    DateTime dt2 = new DateTime(2017, 2, 21, 17, 21);
    Interval interval = new Interval(dt1.getMillis(), dt2.getMillis());
    Period p = interval.toPeriod();
    System.out.println(p.toString());
    System.out.println("years:" + p.getYears()+";months:"+p.getMonths()
            +";days:"+p.getDays()+";hours:"+p.getHours()
            +";minutes:"+p.getMinutes()+";seconds:"+p.getSeconds()
            +";mills:"+p.getMillis());
    
    //链式代码
    DateTime dateTime=new DateTime(2017,2,21,0,0);
    System.out.println(dateTime.dayOfMonth()
        .setCopy(28)//穿越到2017-02-28
        .minusYears(9)//穿越到9年前
        .dayOfMonth()
        .withMaximumValue()//穿越到那年那月的最后一天，那天是29日
        .dayOfWeek()
        //.get()//29日那天是星期五
        .setCopy(1)//(不管29日是星期几)穿越到29日那天所在的星期一
        //Hello,我来过 2008-02-25T00:00:00.000+08:00
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30

## 七、重复注解 ##

java8之前一个注解在一个位置只能标注一次，java8允许标注多次。

注解定义：

@Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    public @interface Filters { 
            Filter[] value();
    }
    
    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    @Repeatable( Filters.class )
    public @interface Filter { 
            String value();
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12

在java8 中标注：

@Filter( "filter1" )
    @Filter( "filter2" )
    public void sayHi(){}
     
      
       1
       2
       3

编译器隐式地增加了一个Filters注解。查询注解可以看到：

@com.pollyduan.annotation.Filters(value=[@com.pollyduan.annotation.Filter(value=filter1), @com.pollyduan.annotation.Filter(value=filter2)])
     
      
       1

在这之前实现同一目标需要这么做：

@Filters({
       @Filter("filter1"),@Filter("filter2")})
    public void sayHi(){}
     
      
       1
       2

实际上这是一致的，也就是说java8的重复注解是一个语法糖，编译器会自动包装成之前的格式。

## 八、Base64 ##

Base64在java8中转正了，不需要再使用`sun.misc.BASE64Encoder`和`sun.misc.BASE64Decoder`了， 而是`java.util.Base64`,这是一个工厂类，它用来创建两个内部实现类：

Encoder encoder = Base64.getEncoder();
    String str="abcd";
    String enc=encoder.encodeToString(str.getBytes());
    System.out.println(enc);
    
    System.out.println(new String(Base64.getDecoder().decode(enc)));
     
      
       1
       2
       3
       4
       5
       6

## 九、Nashorn - a new javascript engine ##

## 十、异常捕获的改变 ##

新的try…cache可以自动关闭在try表达式中打开的对象，而无需开发者手动关闭。

多个流对象打开语句，用分号分隔，不是逗号。

try(ObjectInputStream in=new ObjectInputStream(new FileInputStream("p1.obj"))){
            System.out.println(Person.class.hashCode());
            Person person=(Person)in.readObject();
            System.out.println(person.staticString);
        }  catch (Exception e) {
            e.printStackTrace();
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8

不再需要：

finally{
        in.close();
    }
     
      
       1
       2
       3

## 十一、nashorn ##

Java8 更新了JavaScript引擎，从jdk6引入的`Mozilla Rhino`引擎改为使用`nashorn`。

测试一下，首先编写一个js文件my.js。

function myfun(str){ 
        return str+new Date();
    }
     
      
       1
       2
       3

java调用js：

package com.pollyduan.nashron;
    
    import java.io.FileReader;
    
    import javax.script.ScriptEngine;
    import javax.script.ScriptEngineManager;
    
    public class NashornTest { 
    
        public static void main(String[] args) throws Exception {
            ScriptEngine nashorn = new ScriptEngineManager().getEngineByName("js");  
            nashorn.eval(new FileReader("src/main/resources/my.js"));
            Object ret = nashorn.eval("myfun(\"Hello,It\'s \")");
            System.out.println(ret);
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16

在java6、7自动使用`rhino`引擎,在java8则自动使用`nashorn`引擎。

java8中，建议显示指定使用`nashorn`:

ScriptEngine nashorn = new ScriptEngineManager().getEngineByName("nashorn");  
     
      
       1

如果项目曾经使用过`rhino`，在移植到java8时，需要引入依赖并指定engineName为`rhino`。

<dependency>
        <groupId>cat.inspiracio</groupId>
        <artifactId>rhino-js-engine</artifactId>
        <version>1.7.7.1</version>
    </dependency>
     
      
       1
       2
       3
       4
       5

同时java修改：

ScriptEngine nashorn = new ScriptEngineManager().getEngineByName("rhino");
     
      
       1

## 小结 ##

java8，节操洒了一地。很多的改变违背了面向对象的初衷，多重继承、函数指针都有了，你要变成c–语言吗？

有些改变是积极的，不过效果差强人意。像date time api。

诸如Predicate、Optional、stream，从guava借鉴而来，也是不错的。

[http_blog.csdn.net_54powerman_article_details_73188951]: http://blog.csdn.net/54powerman/article/details/73188951
[http_docs.oracle.com_javase_specs_jls_se8_html_index.html]: http://docs.oracle.com/javase/specs/jls/se8/html/index.html
[http_www.importnew.com_8118.html]: http://www.importnew.com/8118.html
[https_jcp.org_en_jsr_detail_id_310]: https://jcp.org/en/jsr/detail?id=310