java8新特性

Java8新特性（十大）
Java8新特性包含语言、编译器、库、工具和JVM等方面的十多个新特性。
1.新特性
1.1.Java语言的新特性
1.1.1.Lambda表达式和函数式接口
1.1.2.接口的默认方法和静态方法
1.1.3.方法引用
1.1.4.重复注解
1.2.Java编译器的新特性
1.2.1.参数名称
1.3.Java官方库的新特性
1.3.1.Optional
https://blog.csdn.net/canot/article/details/52956230
1.3.2.Streams（代替for循环）
1.3.3.Date/Time API
1.3.4.JavaScript引擎Nashorn
1.3.5.Base64
1.3.6.并行数组
1.3.7.并发性
1.4.新的Java工具
1.4.1.Nashorn引擎：jjs
1.4.2.类依赖分析器：jdeps

参考资料：
https://blog.csdn.net/u014470581/article/details/54944384
https://www.cnblogs.com/yw0219/p/7302597.html
https://www.cnblogs.com/pkufork/p/java_8.html

2.Lambda表达式
2.1.Lambda表达式语法结构
2.1.1.标准语法结构
(Type1 param1, Type2 param2, …, TypeN paramN) -> {
statment1;
statment2;
//………….
return statmentM;
}

2.1.2.单参数语法结构
当lambda表达式的参数个数只有一个，可以省略小括号
2.1.3.单语句写法
当lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号
2.1.4.方法引用写法
Class or instance :: method
2.2.lambda表达式的本质
Lambda表达式本质上是一个匿名方法。
例如：
public int add(int x, int y) {
return x + y;
}

转成Lambda表达式后是这个样子：
(int x, int y) -> x + y;
参数类型也可以省略，Java编译器会根据上下文推断出来：
(x, y) -> x + y; //返回两数之和
或者
(x, y) -> { return x + y; } //显式指明返回值
可见Lambda表达式有三部分组成：参数列表，箭头（->），以及一个表达式或语句块。

将函数当成参数传递给某个方法

3.函数式接口
函数式接口就是只显式声明一个抽象方法的接口。为保证方法数量不多不少，java8提供了一个专用注解@FunctionalInterface，这样，当接口中声明的抽象方法多于或少于一个时就会报错。如下图所示：

4.接口的默认方法与静态方法
4.1.接口的默认方法
可以在接口中定义默认方法，使用default关键字，并提供默认的实现。所有实现这个接口的类都会接受默认方法的实现，除非子类提供的自己的实现。
4.2.接口的静态方法
可以在接口中定义静态方法，使用static关键字，也可以提供实现。

举例：
接口定义
package java8;

public interface InterfaceFunctional {

// static修饰符定义静态方法  
static void staticMethod() {  
    System.out.println("InterfaceFunctional接口中的静态方法");  
}  

// default修饰符定义默认方法  
default void defaultMethod() {  
    System.out.println("InterfaceFunctional接口中的默认方法");  
}  

}

实现类
package java8;

public class InterfaceFunctionalImpl implements InterfaceFunctional {

}

测试类：
package java8;

public class Test {

public static void main(String[] args) {
    InterfaceFunctionalImpl impl = new InterfaceFunctionalImpl();
    impl.defaultMethod();

    InterfaceFunctional.staticMethod();
}

}

输出结果：
InterfaceFunctional接口中的默认方法
InterfaceFunctional接口中的静态方法

5.方法引用
举例：
package java8;

import java.util.function.Supplier;

public class FunctionalReference {

public static FunctionalReference create(final Supplier supplier) {
    return supplier.get();
}

public static void collide(final FunctionalReference reference) {
    System.out.println("Collided " + reference.toString());
}

public void follow(final FunctionalReference another) {
    System.out.println("Following the " + another.toString());
}

public void repair() {
    System.out.println("Repaired " + this.toString());
}

}

方法引用举例：
package java8;

import java.util.Arrays;
import java.util.List;

public class FunctionalReferenceTest {

public static void main(String[] args) {
    // 第一种方法引用的类型是构造器引用，语法是Class::new，或者更一般的形式：Class::new。注意：这个构造器没有参数。
    final FunctionalReference reference = FunctionalReference.create( FunctionalReference::new );
    final List< FunctionalReference > references = Arrays.asList( reference );

    // 第二种方法引用的类型是静态方法引用，语法是Class::static_method。注意：这个方法接受一个FunctionalReference类型的参数。
    references.forEach( FunctionalReference::collide );

    // 第三种方法引用的类型是某个类的成员方法的引用，语法是Class::method，注意，这个方法没有定义入参：
    references.forEach( FunctionalReference::repair );

    // 第四种方法引用的类型是某个实例对象的成员方法的引用，语法是instance::method。注意：这个方法接受一个Car类型的参数：
    final FunctionalReference reference2 = FunctionalReference.create( FunctionalReference::new );
    references.forEach( reference2::follow );
}

}

6.Streams
是一种迭代器
https://blog.csdn.net/u010425776/article/details/52344425
6.1.流的获取
// 集合
List list = new ArrayList();
Stream stream = list.stream();

    // 数组 
    String[] names = {"chaimm","peter","john"};
    Stream stream2 = Arrays.stream(names);

    // 值
    Stream stream3 = Stream.of("chaimm","peter","john");

    // 文件
    try {
        Stream lines = Files.lines(Paths.get("文件路径名"),Charset.defaultCharset());
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

6.2.使用：
List list1 = Arrays.asList(1,2,3,4);
Stream stream4 = list1.stream();
stream4.map(i -> i+1).forEach(System.out::println);

    List alpha = Arrays.asList("a", "b", "c", "d");
    //Before Java8
    List alphaUpper = new ArrayList<>();
    for (String s : alpha) {
        alphaUpper.add(s.toUpperCase());
    }

    System.out.println(alpha); //[a, b, c, d]
    System.out.println(alphaUpper); //[A, B, C, D]

    // Java 8
    List collect = alpha.stream().map(String::toUpperCase).collect(Collectors.toList());
    System.out.println(collect); //[A, B, C, D]

    // Extra, streams apply to any data type.
    List num = Arrays.asList(1,2,3,4,5);
    List collect1 = num.stream().map(n -> n * 2).collect(Collectors.toList());
    System.out.println(collect1); //[2, 4, 6, 8, 10]