Java8的其他新特性

1 - Java 8新特性简介

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

新特性思维导图

Java8新特性总结：

　　✔ 速度更快
　　✔ 代码更少(增加了新的语法：Lambda 表达式)
　　✔ 强大的 Stream API
　　✔ 便于并行
　　✔ 最大化减少空指针异常：Optional
　　✔ Nashorn引擎，允许在JVM上运行JS应用

并行流与串行流

①并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。
②Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换

2 - Lambda表达式

1 为什么使用 Lambda 表达式？

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

2 从匿名类到 Lambda 的转换举例

package com.lzh.java2;

import org.junit.Test;
import java.util.Comparator;
/*
lambda表达式的使用举例：匿名实现类转换为lambda表达式
 */
public class LambdaTest {
    @Test
    public void test1(){
        // 匿名实现类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("welcome to the world of Java");
            }
        };
        runnable.run();

        // lambda表操作符：->
        Runnable r1 = () -> System.out.println("I believe I can fly");
        r1.run();
    }
    
    @Test
    public void test2(){
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        System.out.println(comparator.compare(11,12)); // -1

        // lambda表达式写法
        Comparator<Integer> comparator1 = (o1,o2) -> Integer.compare(o1,o2);
        int value = comparator1.compare(21,10);
        System.out.println(value); // 1

        // 方法引用 ::
        Comparator<Integer> comparator2 = Integer :: compareTo;
        int value2 = comparator2.compare(14,10);
        System.out.println(value2);

    }
}

匿名类转换到lambda表达式

3 lambda表达式的使用

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ，该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：
　　左侧：指定了 Lambda 表达式需要的参数列表

　　右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能

/*
lambda表达式(函数式接口)的使用：
    1. 举例：(o1,o2) -> Integer.compare(o1,o2);
    2. 格式：
        ->：lambda操作符 或 箭头操作符
        ->左边：lambda形参列表 (其实就是接口中的抽象方法的形参列表)
        ->右边：lambda体 (其实就是重写的抽象方法的方法体)

    3. lambda表达式的使用：
        以下代码6种语法格式
        总结：
            ->左边：lambda形参列表参数类型可以省略；如果lambda形参列表只有一个参数，其一对()也可以省略
            ->右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句(可能是return语句)，可以省略这一对{}和return关键字

    4. lambda表达式的本质：接口的一个实例
        对接口的要求：只能有一个抽象方法

    5. 函数式接口：一个接口中，只声明了一个抽象方法，我们可以使用在一个接口上使用@FunctionalInterface注解，检查是否是一个函数式接口

    6. 所以以前用匿名实现类表示的现在都可以使用lambda表达式来写
 */

// 语法格式1：无参、无返回值类型

@Test // 语法格式1：无参、无返回值类型
    public void test1(){
        // 常规写法
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("执行run()方法");
            }
        };
        // lambda表达式写法
        Runnable runnable = () -> {
            System.out.println("执行run()方法");
        };
    }

View Code

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

@Test // 语法格式2：Lambda 需要一个参数，但是没有返回值
    public void test2(){
        // 常规写法
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer1.accept("I believe I can fly!");

        // lambda表达式写法
        Consumer<String> consumer2 = (String s) -> {
            System.out.println(s);
        };
        consumer2.accept("I believe I can fly!");
    }

View Code

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

    @Test // 语法格式3：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    public void test3(){
        List<Integer> list = new ArrayList<>(); // 类型推断
        int[] array = {1,2,3}; // ；类型推断
        // 基于需要一个参数，无返回值写法的优化：类型推断
        Consumer<String> consumer = (s) -> {
            System.out.println(s);
        };
        consumer.accept("welcome to the world of java");
    }

View Code

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

@Test // 语法格式4：Lambda 若只需要一个参数时，参数的小括号可以省略
    public void test(){
        Consumer<String> consumer = str -> {
            System.out.println(str);
        };
        consumer.accept("you got a dream,you gotta protect it.");
    }

View Code

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

@Test // 语法格式5：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
    public void test5(){
        // 常规写法
        Comparator<Integer> comparator1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                // return Integer.compare(o1,o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator1.compare(12,11));

        // lambda表达式写法
        Comparator<Integer> comparator2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            // return Integer.compare(o1,o2);
            return o1.compareTo(o2);
        };
        System.out.println(comparator2.compare(10,9));
    }

View Code

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

    @Test // 语法格式6：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
    public void test6(){
        // 常规写法
        Comparator<Integer> comparator1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };

        // lambda表达式
        Comparator<Integer> comparator2 = (o1,o2) -> o1.compareTo(o2);
        System.out.println(comparator2.compare(11,3)); // 1
    }

View Code

3 - 函数式(Functional)接口

1 什么是函数式(Functional)接口？

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

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

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

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

2 如何理解函数式接口

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

②  在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的 编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在 Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的 对象类型——函数式接口。 

③  简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是 Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口 的实例，那么该对象就可以用Lambda表达式来表示。  所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

*/

3 自定义函数式接口

4 Java 内置四大核心函数式接口

代码使用举例

package com.lzh.java2;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/*
Java内置的4大核心函数式接口：
    消费型接口 Consumer<T>   void accept(T t)
    供给型接口 Supplier<>    T get()
    函数型接口 Function<T,R> R apply(T t)
    断定型接口 Predicate<T>  boolean test(T t)
 */
public class LambdaTest2 {
    @Test // 消费型接口的代码示例
    public void test1(){
        // 常规写法
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("买了Iphone12,花了" + aDouble);
            }
        });

        // lambda表达式写法
        happyTime(1000,money -> {
            System.out.println("买了Iphone12，花了" + money);
        });

        happyTime(10,money -> System.out.println("买了一瓶水花了" + money));
    }

    public void happyTime(double money, Consumer<Double> consumer){
        consumer.accept(money);
    }

    @Test // 获取带京字的城市名称
    public void test2() {
        List<String> list = Arrays.asList("北京","南京","东京","云南","东北","上海");
        // 常规写法
        List<String> newList = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
//                if(s.endsWith("京")) {
//                    return true;
//                }
//                return false;
                return s.contains("京");
            }
        });

//        for(String s:newList){
//            System.out.println(s);
//        }
        System.out.println(newList); // [北京, 南京, 东京]

        // lambda表达式写法
        List<String> filterList = filterString(list,str -> str.contains("京"));
        System.out.println(filterList); // [北京, 南京, 东京]
    }

    // 根据给定的规则，过滤集合中的字符串，此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> predicate){
        ArrayList<String> filterList = new ArrayList<>();
        for(String s:list){
            if(predicate.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }
}

Consumer与Predicate

5 作为参数传递 Lambda 表达式

4 - 方法引用与构造器引用

1 方法引用(Method References)

　　✔ 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

　　✔ 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
　　✔ 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！
　　✔ 格式：使用操作符 “::” 将类(或对象) 与方法名分隔开来。

　　✔ 如下三种主要使用情况：

　　　　① 对象::实例方法名

　　　　② 类::静态方法名

　　　　③ 类::实例方法名

package com.lzh.java3;

import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 方法引用的使用
 * 1. 使用情景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
 *
 * 2. 方法引用：本质上就是lambda表达式，而lambda表达式作为函数接口的实例。所以方法引用，也是函数式接口的实例
 *
 * 3. 使用格式：类(或对象)  ::  方法名
 * 4. 具体分为如下的三种情况
 *     对象  ::  非静态方法
 *     类  ::  静态方法
 *     类  ::  非静态方法
 *
 *     5. 方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！
 * Created by howie
 */
public class MethodRefTest {

    // 情况一：对象 :: 实例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)
    @Test
    public void test1() {

        // lambda表达式写法
        Consumer<String> consumer1 = (string) -> System.out.println("我喜欢" + string);
        consumer1.accept("Iphone 12"); // 我喜欢Iphone 12

        // 方法引用写法
        PrintStream ps = System.out;
        Consumer<String> consumer2 = ps :: println;
        consumer2.accept("大话数据结构"); // 大话数据结构
    }
    
    //Supplier中的T get()
    //Employee中的String getName()
    @Test
    public void test2() {
        // lambda表达式写法
        Employee employee = new Employee(1001,"李白",22,10000);
        Supplier<String> supplier1 = () -> employee.getName();
        System.out.println(supplier1.get()); // 李白

        // 方法引用写法
        Supplier<String> supplier2 = employee :: getName;
        System.out.println(supplier2.get()); // 李白
        
    }

    // 情况二：类 :: 静态方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test3() {
        // lambda表达式写法
        Comparator<Integer> comparator1 = (o1,o2) -> {
            return o1.compareTo(o2);
        };
        // Comparator<Integer> comparator1 = (o1,o2) -> Integer.compare(o1,o2);
        System.out.println(comparator1.compare(12,11)); // 1

        // 方法引用写法
        Comparator<Integer> comparator2 = Integer :: compare;
        System.out.println(comparator2.compare(12,11)); // 1
    }
    
    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void test4() {
        // 常规写法
        Function<Double,Long> function1 = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble); // 四舍五入方法
            }
        };
        System.out.println(function1.apply(12.1)); // 12

        // lambda表达式写法
        Function<Double,Long> function2 = num -> Math.round(num);
        System.out.println(function2.apply(12.1)); // 12

        // 方法引用
        Function<Double,Long> function3 = Math :: round;
        System.out.println(function3.apply(12.1)); // 12
    }

    // 情况三：类 :: 实例方法 
    // Comparator中的int comapre(T t1,T t2)
    // String中的int t1.compareTo(t2)
    @Test
    public void test5() {
        // lambda表达式写法
        Comparator<String> comparator1 = (t1,t2) -> t1.compareTo(t2);
        System.out.println(comparator1.compare("abc","abd")); // -1

        // 方法引用写法
        Comparator<String> comparator2 = String :: compareTo;
        System.out.println(comparator2.compare("abc","abd")); // -1
    }

    //BiPredicate中的boolean test(T t1, T t2);
    //String中的boolean t1.equals(t2)
    @Test
    public void test6() {
        // lambda表达式写法
        BiPredicate<String,String> bp1 = (t1,t2) -> t1.equals(t2);
        System.out.println(bp1.test("abc","abc")); // true

        // 方法引用写法
        BiPredicate<String,String> bp2 = String :: equals;
        System.out.println(bp2.test("abc","abc")); // true

    }
    
    // Function中的R apply(T t)
    // Employee中的String getName();
    @Test
    public void test7() {
        Employee employee = new Employee(1001,"alex",21,10000);
        // lambda表达式写法
        Function<Employee,String> function1 = e -> e.getName();
        System.out.println(function1.apply(employee)); // alex

        // 方法引用写法
        Function<Employee,String> function2 = Employee :: getName;
        System.out.println(function2.apply(employee)); // alex
    }

}

方法引用代码举例

2 构造器引用

　　格式： ClassName::new

　　与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，要求构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象。

3 数组引用

　　格式： type[] :: new

package com.lzh.java3;

import org.junit.Test;

import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 一、构造器引用
 *      和方法引用类似，函数接口的抽象方法的形参列表和构造器的形参列表一致，抽象方法的返回值类型即为构造器所属的类的类型
 * 二、数组引用
 *      可以把数组看做是一个特殊的类，则写法与构造器引用一致
 *
 * Created by howie
 */
public class ConstructorRefTest {
    // 构造器引用
    // Supplier中的T get()
    // Employee空参构造器：Employee()
    @Test
    public void test1(){
        // 常规写法
        Supplier<Employee> supplier1 = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println(supplier1.get());

        // lambda表达式写法
        Supplier<Employee> supplier2 = () -> new Employee();
        System.out.println(supplier2.get());

        // 构造器引用
        Supplier<Employee> supplier3 = Employee :: new;
        System.out.println(supplier3.get());

    }

    //Function中的R apply(T t)
    @Test
    public void test2(){
        // lambda表达式写法
        Function<Integer,Employee> function1 = id -> new Employee(id);
        System.out.println(function1.apply(1001));

        // 构造器引用写法
        Function<Integer,Employee> function2 = Employee :: new;
        System.out.println(function2.apply(1001));
    }

    //BiFunction中的R apply(T t,U u)
    @Test
    public void test3(){
        // lambda表达式写法
        BiFunction<Integer,String,Employee> bf1 = (id,name) -> new Employee(id,name);
        System.out.println(bf1.apply(1001,"alex"));

        // 构造器引用
        BiFunction<Integer,String,Employee> bf2 = Employee :: new;
        System.out.println(bf2.apply(1001,"alex"));
    }

    //数组引用
    //Function中的R apply(T t)
    @Test
    public void test4(){
        // lambda表达式写法
        Function<Integer,String[]> function1 = length -> new String[length];
        String[] arrayString = function1.apply(5);
//        for(String s:arrayString){
//            System.out.println(s);
//        }
        System.out.println(Arrays.toString(arrayString)); // [null, null, null, null, null]

        // 数组引用写法
        Function<Integer,String[]> function2 = String[] :: new;
        String[] array = function2.apply(5);
        System.out.println(Arrays.toString(array)); // [null, null, null, null, null]
    }
}

构造器引用与数组引用举例

5 - Stream API说明

1 说明：

　　1 Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API。

　　2 Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

　　3 Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用 Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。 也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

2 为什么要使用Stream API ？

　　1 实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要 Java层面去处理。

　　2 Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。

3 什么是 Stream ？

　　1 Stream到底是什么呢？是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据，Stream讲的是计算！”

　　2 注意：

　　　　①Stream 自己不会存储元素。

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

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

4 总结

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

2 说明：
    ① Stream 自己不会存储元素
    ② Stream 不会改变源对象。相反，他们会返回一个特有结果的新Stream
    ③ Stream 操作时延迟执行的。这意味着他们会等到需要结果的时候才执行

3 Stream 执行流程
    ① Stream实例化
    ② 一系列中间操作(过滤、映射等)
    ③ 终止操作

4 中间操作的说明：
    ① 一个中间操作链，对数据源的数据进行处理
    ② 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
 */

6 - Stream 的操作三个步骤

1 - 创建 Stream
一个数据源（如：集合、数组），获取一个流

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

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

7 - Stream 的创建

1 创建 Stream方式1：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

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

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

@Test
    // 创建Stream方式1：通过集合
    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();
    }

方式1

2 创建 Stream方式2：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

✔ static <T> Stream<T> stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：

　　① public static IntStream stream(int[] array)

　　② public static LongStream stream(long[] array)

　　③ public static DoubleStream stream(double[] array)

@Test
    // 创建Stream方式2：通过数组
    public void test2(){
        int[] array = new int[]{14,2,3,4,5,6,7};
        // 调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream intStream = Arrays.stream(array);

        Employee e1 = new Employee(1001,"李白");
        Employee e2 = new Employee(1002,"韩信");
        Employee[] employees = new Employee[]{e1,e2};
        Stream<Employee> employeeStream = Arrays.stream(employees); // 自定义数组类型
    }

方式2

3 创建 Stream方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

✔ public static<T> Stream<T> of(T... values) : 返回一个流

  @Test
    // 创建Stream方式3：通过Stream的of()
    public void test3(){
        Stream<Integer> integerStream = Stream.of(1,2,3,4,5,6);
    }

方式3

4 创建 Stream方式四：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

① 迭代 public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

② 生成 public static<T> Stream<T> generate(Supplier<T> s)

 @Test
    // 创建Stream方式4：创建无限流
    public void test4(){
        // 迭代 public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        // 遍历前10个偶数数
        Stream.iterate(0,t -> t + 2).limit(10).forEach(System.out :: println);

        // 生成 public static<T> Stream<T> generate(Supplier<T> s)
        // 输出5随机数
        Stream.generate(Math :: random).limit(5).forEach(System.out :: println);

    }

方式4

8 - Stream 的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

1 - 筛选与切片

代码举例

@Test
    // 1 筛选与切片
    public void test1(){
        List<Employee> employeeList = EmployeeData.getEmployees();

        // filter(Predicate p) 接收 Lambda ， 从流中排除某些元素
        // 练习：查询员工表中薪资大于7000的员工信息
        Stream<Employee> employeeStream = employeeList.stream();
        employeeStream.filter(e -> e.getSalary() > 7000).forEach(System.out :: println);

        // limit(long maxSize) 截断流，使其元素不超过给定数量
        System.out.println();
        Stream<Employee> streamList = employeeList.stream();
        streamList.limit(3).forEach(System.out :: println); // 查询前3条数据

        // skip(long n) 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一 个空流。与 limit(n) 互补
        System.out.println();
        Stream<Employee> streamList1 = employeeList.stream();
        streamList1.skip(3).forEach(System.out :: println); // 跳过前3条数据

        // distinct() 筛选(去重)，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        System.out.println();
        employeeList.add(new Employee(1001, "马化腾", 22, 6000.38));
        employeeList.add(new Employee(1001, "马化腾", 22, 6000.38));
        employeeList.add(new Employee(1001, "马化腾", 22, 6000.38));
        employeeList.add(new Employee(1001, "马化腾", 22, 6000.38));

        // System.out.println(employeeList);
        Stream<Employee> streamList2 = employeeList.stream();
        streamList2.distinct().forEach(System.out :: println); // 此时数据中有两个马化腾
    }

筛选与切片

2 - 映射

@Test
    // 2 映射
    public void test2(){
        // map(Function f) 接收一个函数作为参数，将元素转换成其他形式或提取信息,该函数会被应用到每个元素上，并将其映射成一个新的元素
        // 举例
        List<String> list = Arrays.asList("aa","bb","cc");
        Stream<String> stringStream = list.stream();
        stringStream.map(s -> s.toUpperCase()).forEach(System.out :: println); // 输出大写

        // 练习：获取员工姓名长度大于3的员工的姓名
        System.out.println();
        List<Employee> employeeList = EmployeeData.getEmployees();
        Stream<String> nameStream = employeeList.stream().map(e -> e.getName());
        nameStream.filter(e -> e.length() > 3).forEach(System.out :: println);

        // flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
    }

映射

3 - 排序

① sorted() 　　产生一个新流，其中按自然顺序排序
② sorted(Comparator com) 　　产生一个新流，其中按比较器顺序排序

 @Test
    // 3 排序
    public void test3(){
        // sorted() 产生一个新流，其中按自然顺序排序
        List<Integer> list = Arrays.asList(11,21,54,14,78,1);
        list.stream().sorted().forEach(System.out :: println);


        // List<Employee> employees = EmployeeData.getEmployees();
        // employees.stream().sorted().forEach(System.out :: println);
        // 抛异常。原因：employee类没有实现comparable接口

        // sorted(Comparator com) 产生一个新流，定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1,e2) -> Integer.compare(e1.getAge(),e2.getAge())).forEach(System.out :: println);
    }

排序

9 - Stream 的终止操作

✔ 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

✔ 流进行了终止操作后，不能再次使用

1 - 匹配与查找

allMatch(Predicate p) 　　检查是否匹配所有元素

anyMatch(Predicate p) 　　检查是否至少匹配一个元素

noneMatch(Predicate p)　　检查是否没有匹配所有元素

findFirst() 　　返回第一个元素

findAny() 　　返回当前流中的任意元素

count() 　　返回流中元素总数

max(Comparator c) 　　返回流中最大值

min(Comparator c) 　　返回流中最小值

forEach(Consumer c)　　内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)

    @Test
    // 1 匹配与查找
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();

        // allMatch(Predicate p) 检查是否匹配所有的元素
        // 练习：是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(employee -> employee.getAge() > 18);
        System.out.println(allMatch); // false

        // anyMatch(Predicate p) 检查是否至少匹配一个元素
        // 练习：是否存在员工的工资大于 10000
        boolean anyMatch = employees.stream().anyMatch(employee -> employee.getSalary() > 10000);
        System.out.println(anyMatch); // false

        // noneMatch(Predicate p) 检查是否没有匹配的元素
        // 练习：是否存在员工姓"雷" (如果有返回false)
        boolean noneMatch = employees.stream().noneMatch(employee -> employee.getName().startsWith("雷"));
        System.out.println(noneMatch); // false

        // findFirst() 返回第一个元素
        Optional<Employee> employeeFirst = employees.stream().findFirst();
        System.out.println(employeeFirst); // Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]

        // findAny() 返回当前流中的任意元素
        Optional<Employee> anyEmployee = employees.stream().findAny();
        System.out.println(anyEmployee); // 随意返回一个Optional<Employee>

        // count()  返回流中元素的总个数
        long numberEmployee = employees.stream().filter(employee -> employee.getSalary() > 6000).count();
        System.out.println(numberEmployee); // 4

        // max(Comparator c) 返回流中最大值
        // 练习：返回最高的工资
        // Optional<Employee> maxSalary = employees.stream().sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary())).findFirst();
        Optional<Double> maxSalary = employees.stream().map(employee -> employee.getSalary()).max((e1, e2) -> Double.compare(e1, e2));
        System.out.println(maxSalary);

        // min(Comparator c) 返回流中最小值
        // 练习：返回最低的工资
        Optional<Employee> employee = employees.stream().min((e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary()));
        System.out.println(employee); // Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]

        // forEach(Consumer c) 迭代内部元素
        employees.stream().forEach(System.out :: println);
    }

匹配与查找代码举例

2 - 归约

reduce(T iden, BinaryOperator b)　　可以将流中元素反复结合起来，得到一个值。返回 T

reduce(BinaryOperator b)　　可以将流中元素反复结合起来，得到一个值。返回 Optional<T>

备注：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。

@Test
    // 2 归约
    public void test2(){
        // reduce(T identity, BinaryOperator b)  可以将流中元素反复结合起来，得到一 个值。返回 T
        // 练习：计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0,Integer :: sum);
        System.out.println(sum); // 55

        // reduce(BinaryOperator b)  可以将流中元素反复结合起来，得到一 个值。返回 Optional<T>
        // 练习：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Optional<Double> sumSalary = employees.stream().map(Employee::getSalary).reduce(Double::sum);
        System.out.println(sumSalary); // Optional[48424.08]

    }

归约代码举例

3 - 收集

collect(Collector c)　　将流转换为其他形式。接收一个 Collector 接口的实现，用于给Stream中元素做汇总的方法

说明：Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、 Map)。

 @Test
    // 3 收集
    public void test(){
        // collect(Collector c)将流转换为其他形式。接收一个 Collector 接口的实现，用于给Stream中元素做汇总 的方法
        // 练习1：查找工资大于6000的员工，结果返回为一个List或Set
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> newEmployees = employees.stream().filter(employee -> employee
                .getSalary() > 6000).collect(Collectors.toList());
        newEmployees.forEach(System.out :: println);

        System.out.println();

        Set<Employee> employeeSet = employees.stream().filter(employee -> employee.getSalary() > 6000)
                .collect(Collectors.toSet());
        employeeSet.forEach(System.out :: println);

    }

收集代码举例

另外Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

10 - Optional类

✔ 到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类， Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

✔ 理解：为了解决java中的空指针问题而生！

✔ Optional<T> 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

✔ Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

✔Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

✔ 创建Optional类对象的方法：

　　1 Optional.of(T t) : 创建一个 Optional 实例，t必须非空；

　　2 Optional.empty() : 创建一个空的 Optional 实例

　　3 Optional.ofNullable(T t)：t可以为null

✔ 判断Optional容器中是否包含对象：

　　1 boolean isPresent() : 判断是否包含对象

　　2 void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer 接口的实现代码，并且该值会作为参数传给它。

✔ 获取Optional容器的对象：

　　1 T get(): 如果调用对象包含值，返回该值，否则抛异常

　　2 T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。

　　3 T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由 Supplier接口实现提供的对象。

　　4 T orElseThrow(Supplier<? extends X> exceptionSupplier) ：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

package com.lzh.java;
import org.junit.Test;
import java.util.Optional;

/*
Optional使用代码举例：
 */
public class OptionalTest {
    @Test
    public void test(){
        // 创建的Optional对象内部的value = null
        Optional<Object> op1 = Optional.empty();
        if (!op1.isPresent()){ // 判断Optional封装的数据是否为空
            System.out.println("数据为空");
        }
        System.out.println(op1);
        System.out.println(op1.isEmpty());
        // 如果Optional分装的数据value为空，则get()报错。否则，value不为空时，返回value
        // System.out.println(op1.get());
        // get() 通常与of()方法搭配使用
    }

    @Test
    public void test2(){
        String str = "hello";
        // of(T t) 封装数据t生成Optional对象。要求t非空，否则报错
        Optional<String> optionalS = Optional.of(str);
        System.out.println(optionalS.get());
    }

    @Test
    public void test3(){
        String str = null;
        // ofNullable(T t) 封装数据t赋给Optional内部的value。不要求t非空
        Optional<Object> optional = Optional.ofNullable(str);
        // orElse(T t1) 如果Optional内部的value非空，则返回此value值，如果value为空，则返回t1
        optional.orElse("hello");
        // ofNullable(T t) 通常与 orElse(T t1) 搭配使用
    }
}

Optional的使用代码举例

package com.lzh.java4;

import org.junit.Test;

import java.util.Optional;

public class OptionalTest {
    @Test
    public void test1(){
        //  Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
        Optional<Girl> optionalGirl1 = Optional.of(new Girl());
        //  Optional.empty() : 创建一个空的 Optional 实例

        //  Optional.ofNullable(T t)：t可以为null
        Optional<Girl> optionalGirl2 = Optional.ofNullable(new Girl());
        System.out.println(optionalGirl2); // Optional[Girl{name='null'}]
    }

    private String getGirlName(Boy boy){
        return boy.getGirl().getName();
    }
    @Test
    public void test2(){
        Boy boy = new Boy();
        Girl girl = boy.getGirl(); // 此时Girl对象并没有创建，报空指针异常
    }
    // 优化以后的getGirlName()方法
    private String newGetGirlName1(Boy boy){
        if(boy != null){
            Girl girl = boy.getGirl();
            if(girl != null){
                return girl.getName();
            }
        }
        return null;
    }
    // 使用Optional以后的getGirlName()方法
    public String newGetGirlName(Boy boy){
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        // 此时的boy1一定非空
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("貂蝉")));
        Girl girl = boy1.getGirl();
        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        // girl1一定非空
        Girl girl1 = girlOptional.orElse(new Girl("西施"));

        return girl1.getName();
    }
}

class Boy{
    private Girl girl;

    public Boy() {
    }

    public Boy(Girl girl) {
        this.girl = girl;
    }

    public Girl getGirl() {
        return girl;
    }

    public void setGirl(Girl girl) {
        this.girl = girl;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "girl=" + girl +
                '}';
    }
}

class Girl{
    private String name;

    public Girl() {
    }

    public Girl(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Girl{" +
                "name='" + name + '\'' +
                '}';
    }
}

代码举例

posted @ 2020-06-25 22:20 赖正华阅读(191) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

赖正华

路漫漫其修(Java)远兮，吾将上下而求索。

Java8的其他新特性

1 - Java 8新特性简介

2 - Lambda表达式

3 - 函数式(Functional)接口

4 - 方法引用与构造器引用

5 - Stream API说明

6 - Stream 的操作三个步骤

7 - Stream 的创建

8 - Stream 的中间操作

9 - Stream 的终止操作

10 - Optional类

公告