Java语言JDK1.8新特性

（1）Lambda表达式
    将函数当成参数传递给某个方法，或者把代码本身当作数据处理。
    
    List<String> list = Arrays.asList("c", "a", "b");
    list.sort((e1, e2)->e1.compareTo(e2));

（2）接口的默认方法、静态方法和函数式接口
    函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。
    默认方法和静态方法不会破坏函数式接口的定义。

    @FunctionalInterface
    public interface IMyFunTest {
        void testFun();
        
        default String getZxwStr(){
            return "zxw";
        }
        
        static void printZxwStr(){
            System.out.println("zxw");
        }
    }

（3）方法引用
    方法引用和Lambda表达式配合使用，使得java类的构造方法看起来紧凑而简洁。

    public class Test {
        public static void main(String[] args) throws Exception {
            Test test = Test.create(Test::new);
            List<Test> list = Arrays.asList(test);
            list.forEach(Test::staticMethod);
            list.forEach(Test::noParamMethod);
            list.forEach(new Test()::instanceMethod);
        }
        //构造器引用，语法是Class::new
        public static Test create(Supplier<Test> supplier){
            return supplier.get();
        }
        //静态方法引用，语法是Class::static_method
        public static void staticMethod(Test test){
            System.out.println(test.toString());
        }
        //类的成员方法的引用，语法是Class::method，注意，这个方法没有定义入参
        public void noParamMethod(){
            System.out.println(this.toString());
        }
        //实例对象的成员方法的引用，语法是instance::method
        public void instanceMethod(Test test){
            System.out.println(test.toString());
            System.out.println(this.toString());
        }
    }

    // 普通应用场景
    List<String> list = Arrays.asList("a", "c", "b");
    list.sort(String::compareTo);
    list.forEach(System.out::println); //a b c

    //****类的成员方法的引用，加强理解（转）****

    //在函数式接口中的参数里加入对象实例：
    @FunctionalInterface
        interface Printable{
            public void print(AlreadyExistPrint a, String s);
    }
    ​
    //已存在的类
    class AlreadyExistPrint{
        public void PrintString(String s){
                System.out.println(s);
            }
    }
    ​
    //测试通过类名引用成员方法.
    public class ClassMethod {
        public static void main(String[] args) {
            //lambda方式实现: 
            print((a,s) -> {a.PrintString(s);}, new AlreadyExistPrint(), "hello");
            
            //简化写法: 方法引用 (通过类名引用成员方法)
            print(AlreadyExistPrint::PrintString,new AlreadyExistPrint(), "hello");
        }
        
        public static void print(Printable p, AlreadyExistPrint a, String s){
            p.print(a, s);
        } 
    }

   //*************************************************

（4）重复注解
    不是语言层面的改进，而是编译器做的一个trick，底层的技术仍然相同。

    @Repeatable(Persons.class)
    public @interface Person{
        String role() default "";
    }
    @Target(ElementType.TYPE)  
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Persons {
        Person[] value();
    }
    @Person(role="father")
    @Person(role="son")
    public class Man {
        String name="";
    }
    
    public static void main(String[] args) throws Exception {
        for(Person t : Man.class.getAnnotationsByType(Person.class)){
            System.out.println(t.role());
        }
    }
（5）拓宽注解的应用场景
    注解几乎可以使用在任何元素上：局部变量、接口类型、超类和接口实现类，甚至可以用在函数的异常定义上。

（6）更好的类型推断
    List<String> list = new ArrayList<>();
    list.add("a");
    list.addAll(new ArrayList<>()); // JDK1.81之前编译不过

（7）Optional
    of：         把指定的值封装为Optional对象，如果指定的值为null，则抛出NullPointerException
    empty：      创建一个空的Optional对象
    ofNullable： 把指定的值封装为Optional对象，如果指定的值为null，则创建一个空的Optional对象
    get：        如果创建的Optional中有值存在，则返回此值，否则抛出NoSuchElementException
    orElse：     如果创建的Optional中有值存在，则返回此值，否则返回一个默认值
    orElseGet：  如果创建的Optional中有值存在，则返回此值，否则返回一个由Supplier接口生成的值
    orElseThrow：如果创建的Optional中有值存在，则返回此值，否则抛出一个由指定的Supplier接口生成的异常
    filter：     如果创建的Optional中的值满足filter中的条件，则返回包含该值的Optional对象，否则返回一个空的Optional对象
    map：        如果创建的Optional中的值存在，对该值执行提供的Function函数调用
    flagMap：    如果创建的Optional中的值存在，就对该值执行提供的Function函数调用，返回一个Optional类型的值，
                     否则就返回一个空的Optional对象
    isPresent：  如果创建的Optional中的值存在，返回true，否则返回false
    ifPresent：  如果创建的Optional中的值存在，则执行该方法的调用，否则什么也不做

（8）Streams
    将生成环境的函数式编程引入了Java库中。【相对复杂】

    List<String> list = new ArrayList<>();
    list.addAll(Arrays.asList("a", "b", "c"));
    list.stream().filter(e->!e.equals("b")).forEach(System.out::println);

    List<String> strList = Arrays.asList("a,b,cc,b,b,cc".split(","));
    Map<String, Long> sortMap = strList.stream().collect(Collectors.groupingBy(t -> t, Collectors.counting()));
    sortMap.forEach((key, value) -> System.out.println(key + "->" + value));

（9）Date/Time API
    新的时间和日期管理API深受Joda-Time影响，并吸收了很多Joda-Time的精华。
    java.time.*

（10）并行数组
    可以显著加快多核机器上的数组排序。

    long[] arrayOfLong = new long [ 20000 ];        
    Arrays.parallelSetAll( arrayOfLong, index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
    Arrays.stream( arrayOfLong ).limit(10).forEach( i -> System.out.print( i+" " ) );
    System.out.println();
    Arrays.parallelSort( arrayOfLong );        
    Arrays.stream( arrayOfLong ).limit(10).forEach( i -> System.out.print( i+" " ) );

（11）Base64编码支持
    java.util.Base64

（12）并发性
    java.util.concurrent 包下增加了很多新的类和方法。

（13）Nashorn JavaScript引擎
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("JavaScript");
    System.out.println(engine.eval( "function f() { return 1; }; f() + 1;") ); // 2.0

（14）参数名称
    在语言层面（使用反射API和Parameter.getName()）和字节码层面（使用新的 -parameters 参数）提供支持。

    Maven项目配置：
    <configuration>
            <compilerArgument>-parameters</compilerArgument>