Java8的新特性

Java 8新特性简介： 

        Java 8（又称为jdk1.8）是Java语言开发的一个主要版本。Java 8是oracle公司于2014年3月发布，就可以看成是Java 5以来最具革命性的版本。Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量的新特性。

优点：

1）速度更快

2）代码更少（增加了新的语法：Lambda 表达式）

3）强大的Stream API

4）便于并行

5）最大化减少空指针异常：Optional

6）Nashorn引擎，允许在JVM上运行JS应用

并行流与串行流：

        并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。

        Java 8中将并行进行优化，可以很很容易的对数据进行并行操作。

        Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换。

1）使用多核对数组进行排序：

Arrays.parallelSort(numbers);

2）根据特定地条件（比如：素数和非素数）对数组进行分组：

Map<Boolean,List<Integer>> groupByPrimary=numbers.parallelStream().collect(Collectors.groupingBy(s->Utility.isPrime(s)));

3）对数组进行过滤：

Integer[] prims=numbers.parallelStream().filter(s->Utility.isPrime(s)).toArray();

Lambda表达式：

        Lambda是一个匿名函数，可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

使用举例：

import org.junit.Test;

import java.io.OutputStream;
import java.util.Comparator;

/*
    Lambda表达式的使用举例
 */
public class LambdaTest {

    @Test
    public void test1(){
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                System.out.println("Beijing");
            }
        };
        r1.run();
        Runnable r2=()-> System.out.println("Shanghai");
        r2.run();
    }

    @Test
    public void test2(){
        Comparator<Integer> com1=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare1=com1.compare(12,21);
        System.out.println(compare1);//-1

        System.out.println("*****************");

        //Lambda表达式的写法
        Comparator<Integer> com2=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare2=com2.compare(32,21);
        System.out.println(compare2);//1

        System.out.println("*******************");

        //方法引用
        Comparator<Integer> com3=Integer::compare;

        int compare3=com3.compare(32,21);
        System.out.println(compare3);//1
    }
}

Lambda表达式的使用：

1）Lambda表达式：在Java 8语言中引入的一种新的语法元素和操作符。这个操作符为“->”，该操作符被称为Lambda操作符或箭头操作符。他将Lambda分为两个部分

2）举例：(o1,o2) -> Integer.compare(o1,o2);

3）格式：->：Lambda操作符或箭头操作符

                ->左边：Lambda形参列表（其实就是接口中抽象方法的形参列表）

                ->右边：Lambda体（其实就是重写抽象方法的方法体）

4）Lambda表达式的六种语法格式：

        语法格式一：无参，无返回值

                Runnable r1=()->{System.out.println("Hello Lambda!");};

        语法格式二：Lambda需要一个参数，但是没有返回值

                Consummer<String> con=(String str)->{System.out.println(str);};

        语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

                Consumer<String> con=(str)->{System.out.println(str);};

        语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略

                Consumer<String> con=str->{System.out.println(str);};

        语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值

                Comparator<Integer> com=(x,y)->{

                        System.out.println("实现函数式接口方法");

                        return Integer.compare(x,y);

                }

        语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略

                Comparator<Integer> com=(x,y)->Integer.compare(x,y);

总结：

->左边：lambda形参列表的参数类型可以省略（类型推断）；如果lambda形参列表只有一个参数，其一对()也可以省略

->右边：lambda体应该使用一堆{}包裹；如果lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return关键字

5）Lambda表达式的本质：作为接口的实例

import org.junit.Test;

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

/*
Lambda表达式的使用
 */
public class LambdaTest1 {
    //语法格式一：无参，无返回值
    //Runnable r1=()->{System.out.println("Hello Lambda!");};
    @Test
    public void test1(){
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                System.out.println("Beijing");
            }
        };
        r1.run();
        Runnable r2=()-> {System.out.println("Shanghai");};
        r2.run();
    }


    //语法格式二：Lambda需要一个参数，但是没有返回值
    // Consummer<String> con=(String str)->{System.out.println(str);};
    @Test
            public void test2(){
    Consumer<String> con=new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    con.accept("How are you?");

    System.out.println("**************8");

    Consumer<String> con1=(String s)->{
        System.out.println(s);
    };
    con1.accept("I'm fine.");
}
    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    //Consumer<String> con=(str)->{System.out.println(str);};
    @Test
    public void test3(){
        Consumer<String> con1=(String s)->{
            System.out.println(s);
        };
        con1.accept("I'm fine.");

        System.out.println("****************");

        Consumer<String> con2=(s)->{//类型推断
            System.out.println(s);
        };
        con2.accept("I'm fine.");

        System.out.println("*************");
        //其他类型推断情况举例
        ArrayList<String> list=new ArrayList<>();
        int[] arr={1,2,3};
    }

    //语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
    //Consumer<String> con=str->{System.out.println(str);};
    @Test
    public void test4(){
        Consumer<String> con1=(s)->{//类型推断
            System.out.println(s);
        };
        con1.accept("I'm fine.");

        System.out.println("*************");

        Consumer<String> con2=s->{//类型推断
            System.out.println(s);
        };
        con2.accept("I'm fine.");
    }

    //语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值
    // Comparator<Integer> com=(x,y)->{
    //      System.out.println("实现函数式接口方法");
    //      return Integer.compare(x,y);
    // }
    @Test
    public void test5(){
        Comparator<Integer> com1=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare(12,21));
        System.out.println("**************");
        Comparator<Integer> com2=(o1,o2)->{
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com2.compare(12,6));
    }

    //语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略
    //Comparator<Integer> com=(x,y)->Integer.compare(x,y);
    @Test
    public void test6(){
        Comparator<Integer> com1=(o1,o2)->{
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12,6));

        System.out.println("**************");
        Comparator<Integer> com2=(o1,o2)->o1.compareTo(o2);
        System.out.println(com2.compare(12,5));
    }

    @Test
    public void test7(){
        Consumer<String> con1=s->{
            System.out.println(s);
        };
        con1.accept("I'm fine");

        System.out.println("*************");

        Consumer<String> con2=s-> System.out.println(s);
        con2.accept("i'm fine");
    }
}

函数式（Functional）接口：

1）只包含一个抽象方法的接口，称为函数式接口。

2）可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常（即：非运行时异常），那么该异常需要在目标接口的抽象方法上进行声明）。

3）可以在一个接口上使用@Functionallnterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。

4）在java.util.function包下定义了Java 8的丰富的函数式接口。

理解函数式接口：

1）Java从诞生日起就一致倡导“一切皆对象”，在Java里面面向对象（OOP）编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程）。

2）在函数式编程语言当中，函数被当作一等公民对