java8新特性

1. java8新特性概述

2. Lambda表达式

在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：
左侧：指定了 Lambda 表达式需要的参数列表
右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。

Lambda表达式有如下的形式：


上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。
栗子

        //不使用lambda表达式的情况
        Comparator<String> com = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(com.compare("beautiful","pretty"));
        //使用lambda表达式的情况
        Comparator<Integer> com1 = (o1,o2) -> o1.compareTo(o2);
        System.out.println(com1.compare(12,23));

3. 函数式接口

只包含一个抽象方法的接口，称为函数式接口。 我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
函数式接口与Lambda表达式的关系：
在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。
栗子

@FunctionalInterface
public interface MyFunctionInterface<T> {
    public T getValue(T str);
}

public class TestFunction {
    public String  toUpper(MyFunctionInterface<String> mf, String str){
        return mf.getValue(str);
    }
    @Test
    public void test(){
        String str = "abc";
        MyFunctionInterface<String> mf = (s) -> s.toUpperCase();
        System.out.println(toUpper(mf, str));
    }
}

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

栗子

    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京","南京","天津","东京","西京","普京");

        List<String> filterStrs = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });

        System.out.println(filterStrs);


        List<String> filterStrs1 = filterString(list,s -> s.contains("京"));
        System.out.println(filterStrs1);
    }

    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre){

        ArrayList<String> filterList = new ArrayList<>();

        for(String s : list){
            if(pre.test(s)){
                filterList.add(s);
            }
        }

        return filterList;

    }

4. 方法引用和构造器引用

4.1 方法引用

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！
方法引用有如下三种主要使用情况：

1. 对象::实例方法名
2. 类::静态方法名
3. 类::实例方法名

栗子

        //方法引用
        //情景一：实例对象：：方法
        PrintStream ps = System.out;
        Consumer<String> con = ps::println;
        con.accept("aba");
        //情景二：类::静态方法
        Function<Double,Long> fun = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);
            }
        };
        System.out.println(fun.apply(12.3));
        Function<Double,Long> fun1 = (num) -> Math.round(num);
        System.out.println(fun1.apply(12.3));

        Function<Double,Long> fun2 = Math::round;
        System.out.println(fun2.apply(12.3));

        //情景三：类：：实例化方法
        Comparator<String> com = (o1,o2) -> o1.compareTo(o2);
        System.out.println(com.compare("abc", "abc"));

        Comparator<String> com1 = String::compareTo;
        System.out.println(com1.compare("abc","abc"));

4.2 构造器引用

使用格式： ClassName::new
使用要求：
构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象。
栗子

        Supplier<Employee> sup1 = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println("=======================");
        Supplier<Employee> sup2 = () -> new Employee();

        System.out.println("====================");
        Supplier<Employee> sup3 = Employee::new;
        System.out.println(sup3.get());

数组引用，构造器引用的特例，使用形式如下：
数组类型[]::new

        Function<Integer,String[]> fun1 = len -> new String[len];
        Function<Integer,String[]> fun2 = String[]::new;
        String[] arrStr = fun2.apply(12);

5. Stream API

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
Stream 和 Collection 集合的区别:
Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。
Stream 的操作三个步骤

• 1- 创建 Stream
  一个数据源（如：集合、数组），获取一个流
• 2- 中间操作
  一个中间操作链，对数据源的数据进行处理
• 3- 终止操作(终端操作)
  一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

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

创建Stream的方式

        //实例化方式一：通过集合
        List<String> lists = new ArrayList<String>(){{
            add("Amy");
            add("Tom");
            add("Jine");
        }};
        //返回一个顺序流
        Stream<String> stream = lists.stream();
        //返回一个并行流
        Stream<String> stream2 = lists.parallelStream();

        //实例化方式二：通过数组
        int[] nums = {1,2,3,4,5,56};
        IntStream arrStream = Arrays.stream(nums);

        //实例化方式三：通过Stream的of()
        Stream<Integer> integerStream = Stream.of(12, 34, 45);

        //实例化方式四：创建无限流
        //遍历前10个偶数
        //迭代
        Stream.iterate(0,t -> t + 2).limit(10).forEach(System.out::println);

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

Stream中常用的中间操作

Stream 常用的终止操作




多说一句，如果学过Spark的话，这些中间操作和终止操作可以类比于RDD的装换算子和行动算子。

6. Optional类

Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表
这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不
存在，现在 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 consumer) ：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。

• 获取Optional容器的对象：

1. T get(): 如果调用对象包含值，返回该值，否则抛异常
2. T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
3. T orElseGet(Supplier other) ：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
4. T orElseThrow(Supplier exceptionSupplier) ：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
   栗子

public class Girl {

    private String name;

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

    public String getName() {
        return name;
    }

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

    public Girl() {

    }

    public Girl(String name) {

        this.name = name;
    }
}

public class Boy {
    private Girl girl;

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

    public Girl getGirl() {
        return girl;
    }

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

    public Boy() {

    }

    public Boy(Girl girl) {

        this.girl = girl;
    }
}

 //Optional类测试
    @Test
    public void test7(){
        Girl girl1 = new Girl();
        //of(T t )的参数t不可以为空
       // girl1 = null;
        Optional<Girl> girl2 = Optional.of(girl1);
        System.out.println(girl2);
        girl1 = null;
        //ofNullable(T t) 参数t可以为空
        Optional<Girl> girl3 = Optional.ofNullable(girl1);
        System.out.println(girl3);
        //判断是否包含对象
        System.out.println(girl3.isPresent());

        //empty() 创建一个空的 Optional 实例
        Optional<Girl> girl4 = Optional.empty();
        System.out.println(girl4.isPresent());

        Optional<Girl> girl5 = Optional.ofNullable(new Girl());
        girl5.ifPresent(girl -> System.out.println(girl));

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

        Boy boy1 = null;
        System.out.println(boy1);
        Boy boy2 = new Boy(new Girl("Zhuli"));
        System.out.println(boy2);

    }
    //获取女友名字
    public String getGirlName(Boy boy){
        Optional<Boy> boy1 = Optional.ofNullable(boy);
        //boy2一定不为空
        Boy boy2 = boy1.orElse(new Boy(new Girl("Amy")));
        Girl girl = boy2.getGirl();
        Optional<Girl> girl1 = Optional.ofNullable(girl);
        Girl girl2 = girl1.orElse(new Girl("Jane"));
        //girl2不为空
        return girl2.getName();

    }