Jdk8新特性

1 Stream流的使用

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

public static void main(String[] args) {
        List<String> list = Arrays.asList("hello","","world","hello","","zhang","san","lining","sam","baby");
        //统计非空字符串
        long count = list.stream().filter(e -> !e.isEmpty()).count();
        System.out.println("统计非空字符串-->"+count);
        //字符串长度等于3的数量
        long count1 = list.stream().filter(e -> e.length() == 3).count();
        System.out.println("统计长度等于3的字符串数量-->"+count1);
        //根据某种条件重新筛选出list集合
        List<String> collect = list.stream().filter(e -> !e.isEmpty()).collect(Collectors.toList());
        System.out.println("不为空的字符串列表-->"+collect);
        //合并字符串
        String collect1 = list.stream().filter(e -> !e.isEmpty()).collect(Collectors.joining(","));
        System.out.println("合并字符串-->"+collect1);
        //去重
        List<String> collect2 = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重-->："+collect2);
        //排序
        /*System.out.println("排序：");
        Random random = new Random();
        random.ints().limit(10).sorted().forEach(System.out::println);*/
        //并行处理
        long count2 = list.parallelStream().filter(e -> e.isEmpty()).count();
        System.out.println("空字符串并行统计-->"+count2);
    }

2 Lambda表达式

Lambda表达式（也称为闭包）是Java 8中最大和最令人期待的语言改变。它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理：函数式开发者非常熟悉这些概念。很多JVM平台上的语言（Groovy、Scala等）从诞生之日就支持Lambda表达式，但是Java开发者没有选择，只能使用匿名内部类代替Lambda表达式。

Lambda的设计耗费了很多时间和很大的社区力量，最终找到一种折中的实现方案，可以实现简洁而紧凑的语言结构。最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成，例如：

Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );

在上面这个代码中的参数e的类型是由编译器推理得出的，你也可以显式指定该参数的类型，例如：

Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );

如果Lambda表达式需要更复杂的语句块，则可以使用花括号将该语句块括起来，类似于Java中的函数体，例如：

Arrays.asList( "a", "b", "d" ).forEach( e -> {
    System.out.print( e );
    System.out.print( e );
} );

Lambda表达式可以引用类成员和局部变量（会将这些变量隐式得转换成final的），例如下列两个代码块的效果完全相同：

String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach( 
    ( String e ) -> System.out.print( e + separator ) );

final String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach( 
    ( String e ) -> System.out.print( e + separator ) );

Lambda表达式有返回值，返回值的类型也由编译器推理得出。如果Lambda表达式中的语句块只有一行，则可以不用使用return语句，下列两个代码片段效果相同：

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );

Lambda的设计者们为了让现有的功能与Lambda表达式良好兼容，考虑了很多方法，于是产生了函数接口这个概念。函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子。在实践中，函数式接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface（Java 库中的所有相关接口都已经带有这个注解了），举个简单的函数式接口的定义：

@FunctionalInterface
public interface Functional {
    void method();
}

不过有一点需要注意，默认方法和静态方法不会破坏函数式接口的定义，因此如下的代码是合法的。

@FunctionalInterface
public interface FunctionalDefaultMethods {
    void method();
 
    default void defaultMethod() {            
    }        
}

Lambda表达式作为Java 8的最大卖点，它有潜力吸引更多的开发者加入到JVM平台，并在纯Java编程中使用函数式编程的概念。如果你需要了解更多Lambda表达式的细节，可以参考官方文档。

3 方法引用

方法引用使得开发者可以直接引用现存的方法、Java类的构造方法或者实例对象。方法引用和Lambda表达式配合使用，使得java类的构造方法看起来紧凑而简洁，没有很多复杂的模板代码。

import java.util.function.Supplier;

/**
 * @author ypz
 * @date 2021/9/10 9:58
 */
public class Car {
    private String carName = "hongqi";
    private Integer carNum = 15;
    private String carColor = "红色";

    public String getCarName() {
        System.out.println(carName);
        return carName;
    }

    public void setCarName(String carName) {
        this.carName = carName;
    }

    public Integer getCarNum() {
        System.out.println(carNum);
        return carNum;
    }

    public void setCarNum(Integer carNum) {
        this.carNum = carNum;
    }

    public String getCarColor() {
        System.out.println(carColor);
        return carColor;
    }

    public void setCarColor(String carColor) {
        this.carColor = carColor;
    }
    public static Car create(final Supplier<Car> supplier){
        return supplier.get();
    }

    public static void repair(Car car){
        System.out.println("static car"+car.getCarColor());
    }

    public void getCarNum(Car car) {
    }
}

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

/**
 * @author ypz
 * @date 2021/9/10 10:00
 */
public class CarTest {
    //方法引用需要配合lambda表达式
    public static void main(String[] args) {
        //1 构造器引用
        Car car = Car.create(Car::new);
        System.out.println(car.getCarColor());
        List<Car> cars = Arrays.asList(car);
        //2 普通方法引用 没有定义入参
        cars.forEach(Car::getCarNum);
        cars.forEach(Car::getCarName);
        cars.forEach(Car::getCarColor);
        //3 静态方法引用,此方法需要接Car类型的参数
        car.setCarColor("static huang");
        cars.forEach(Car::repair);
        //4 对示例对象引用该类的成员方法,这个方法必须添加car类型的参数
        Car car1 = new Car();
        cars.forEach(car1::getCarNum);


    }
}

4 Optional判空

Java应用中最常见的bug就是空值异常。在Java 8之前，Google Guava引入了Optionals类来解决NullPointerException，从而避免源码被各种null检查污染，以便开发者写出更加整洁的代码。Java 8也将Optional加入了官方库。

Optional仅仅是一个容易：存放T类型的值或者null。它提供了一些有用的接口来避免显式的null检查，可以参考Java 8官方文档了解更多细节。

接下来看一点使用Optional的例子：可能为空的值或者某个类型的值：

public static void main(String[] args) {
        Optional<String> optional = Optional.ofNullable(null);
        //Optional实例为null,则isPresent返回false,
        System.out.println(optional.isPresent()); //false

        Optional<String> zhangsan = Optional.ofNullable("zhangsan");
        System.out.println(zhangsan.isPresent()); //true

        //如果Optional接收的实例为null，则可以接收一个lambda表达式生成一个新的值
        System.out.println(optional.orElseGet(()->"[null]"));
    }

    public Integer hello(){
        Optional<Integer> optional = Optional.ofNullable(null);
        //
        optional.orElseGet(()->123);
        return 0;
    }