JAVA8其它新特性

Lambda表达式

1. Lambda表达式使用前后的对比：

举例一：

@Test

    public void test1(){

        Runnable r1 = new Runnable() {

            @Override

            public void run() {

                System.out.println("我爱北京天安门");

            }

        };

        r1.run();

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

        Runnable r2 =() -> System.out.println("我爱北京");

        r2.run();

    }

举例二：

@Test

    public void test2(){

        Comparator<Integer> com1 = new Comparator<Integer>() {

            @Override

            public int compare(Integer integer, Integer t1) {

                return Integer.compare(integer,t1);

            }

        };

        int compare = com1.compare(23, 23);

        System.out.println(compare);

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

        //Lambda表达式的写法

        Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);

        int compare2 = com2.compare(233, 23);

        System.out.println(compare2);

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

        //方法引用

        Comparator<Integer> com3 =  Integer :: compare;

        int compare3 = com3.compare(233, 2333);

        System.out.println(compare3);

    }

1. Lambda表达式的基本语法：

 * 1. 举例：（O1，O2）-> Integer.Compare(o1,o2)

 * 2. 格式：

 *      ->:Lambda操作符 或箭头操作符

 *      ->:左边：Lambda形参列表(其实就是接口中的抽象方法的形参列表)

 *      ->:右边：Lambda体(其实就是重写的抽象方法的方法体)

1. 如何使用：分为六种情况

总结六种情况：

->左边: Lambda形参列表的参数类型可以省略(类型推断);如果Lambda形参列表只有一个参数，其一对()也可以省

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

函数式接口

1. 函数式接口的使用说明：

• 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。
• 我们可以在一个接口上使用@FunctionaLInterface注解，这样做可以检查它是否是一个函数式接口。
• Lambda表达式的本质：作为接口的实例

1. Java8中关于Lambda表达式提供的4个基本的函数式接口：

具体使用：

1. 总结。

3.1 何时使用1ambda表达式？

当需要对一个函数式接口实例化的时候，可以使用lambda表达式。

3.2何时使用给定的函数式接口？

如果我们开发中需要定义一个函数式接口，首先看看在已有的jdk提供的函数式接口是否提供了能满足需求的函数式接口。如果有，则直接调用即可，不需要自己再自定义了。

方法引用

1. 理解：方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法。
2. 使用情境：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用!
3. 格式：类(或对象) :: 方法名
4. 分为如下的三种情况：

 情況一：        对象 :: 非静态方法

 情況二：        类 :: 静态方法

 情況三：        类 :: 非静态方法

1. 要求：

• 要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同!(针对于情况1和情况2)
• 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时:className : :methodName（针对于情况3）

1. 使用建议：

如果给函数式接口提供实例，恰好满足方法引用的使用情境，大家就可以考虑使用方法引用给函数式接口提供实例。如果大家不熟悉方法引用，那么还可以使用Lambda表达式。

1. 使用举例：

// 情况一：对象 :: 实例方法

//Consumer中的void accept(T t)

//PrintStream中的void println(T t)

@Test

public void test1() {

Consumer<String> con1 = s -> System.out.println(s);

con1.accept("北京");

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

Consumer<String> con2 = System.out :: println;

con2.accept("北京");

}

//Supplier中的T get()

//Employee中的String getName()

@Test

public void test2() {

Employee employee = new Employee(1001,"Tom",23,20000);

Supplier<String> sup1 = () -> employee.getName();

System.out.println(sup1.get());

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

Supplier<String> sup2 = employee::getName;

System.out.println(sup2.get());

}

// 情况二：类 :: 静态方法

//Comparator中的int compare(T t1,T t2)

//Integer中的int compare(T t1,T t2)

@Test

public void test3() {

Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);

System.out.println(com1.compare(122,32));

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

Comparator<Integer> com2 = Integer::compare;

System.out.println(com2.compare(122,322));

}

//Function中的R apply(T t)

//Math中的Long round(Double d)

@Test

public void test4() {

Function<Double,Long> func = new Function<Double,Long>() {

@Override

public Long apply(Double d){

return Math.round( d);

}

};

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

Function<Double,Long> func1 = d -> Math.round(d);

System.out.println(func1.apply(12.2));

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

Function<Double,Long> func2 = Math :: round;

System.out.println(func2.apply(12.6));

}

// 情况三：类 :: 实例方法(有难度)

// Comparator中的int compare(T t1,T t2)

// String中的int t1.compareTo(t2)

@Test

public void test5() {

Comparator<String> com1 = (t1,t2) -> t1.compareTo(t2);

System.out.println(com1.compare("abc", "abg"));

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

Comparator<String> com2 = String::compareTo;

System.out.println(com2.compare("abc", "abm"));

}

//BiPredicate中的boolean test(T t1, T t2);

//String中的boolean t1.equals(t2)

@Test

public void test6() {

BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);

System.out.println(pre1.test("abc" , "abc"));

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

BiPredicate<String, String> pre2 = String :: equals;

System.out.println(pre2.test( "abc",  "abd" ));

}

// Function中的R apply(T t)

// Employee中的String getName();

@Test

public void test7() {

Employee employee = new Employee(1001,"Jerry", 23, 6000);

Function<Employee,String> func1 = e ->e.getName();

System.out.println(func1.apply(employee));

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

Function<Employee,String> func2 = Employee::getName;

System.out.println(func2.apply(employee));

}

构造器引用与数组引用

1. 构造器引用格式：类名::new

1. 构造器引用使用要求：

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型

1. 构造器引用举例：
2. 数组引用格式：数组类型[] :: new
3. 数组引用举例：

 

Stream API

1. Stream API的理解：

1.1  Stream关注的是对数据的运算，与CPU打交道集合关注的是数据的存储，与内存打交道

1.2  java8提供了一套api,使用这套pi可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于sqL对数据库中表的相关操作。

1. 注意点：

① Stream自己不会存储元素。

② Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream

③ Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

1. Stream的使用流程：

 * Stream的实例化(造对象)

 * 一系列的中间操作（过滤、映射、...)

 * 终止操作。

1. 使用流程的注意点：

4.1 一个中间操作链，对数据源的数据进行处理。

4.2 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用。

1. 步骤一：Stream实例化

//创建Stream方式一:通过集合

    @Test

    public void test1() {

        List<Employee> employees = EmployeeData.getEmployees();

//    default Stream<E> stream() :返回一个顺序流

        Stream<Employee> stream = employees.stream();

//    default Stream<E> parallelStream() :返回一个并行流

        Stream<Employee> parallelStream = employees.parallelStream();

    }

    //    创建Stream方式二:通过数组

    @Test

    public void test2() {

        int[] arr = new int[]{1,2,3};

        //调用Arrays类的static <T> Stream<T> stream(T[] array)： 返回一个流

        IntStream stream = Arrays.stream(arr);

        Employee e1 = new Employee(1001,"Tom");

        Employee e2 = new Employee(1002,"Jerry");

        Employee[] arr1 = new Employee[]{e1,e2};

        Stream<Employee> stream1 = Arrays.stream(arr1);

    }

    //创建Stream方式三:通过stream 的of()

    @Test

    public void test3(){

        Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

    }

    //创建Stream方式四:创建无限流

    @Test

    public void test4(){

//        迭代

//        public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

        Stream.iterate( 0, t -> t + 2).limit(10).forEach(System.out::println);

//        生成

//        public static<T> Stream<T> generate(SupplierT> s)

        Stream.generate(Math::random).limit(10).forEach(System.out :: println);

    }

1. 步骤二：中间操作

1. 步骤三：终止操作

Collector需要使用Collectors提供实例。