Java基础（23）-Java8的部分特性（了解）

1. Lambda表达式

想使用Lambda表达式，必须是要接口为函数式接口；Lambda表达式的本质是函数式接口的实例；
匿名实现类现在都可以使用Lambda表达式来表示；
Lambda的简单使用演示；

public class TestLambda {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("这是Lambda测试");
            }
        };
        //运行上面的多线程；
        new Thread(runnable).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("************************");
        //这里使用Lambda表达式，编写上面的程序；
        Runnable run = () -> System.out.println("已经用了Lambda表达式");
        new Thread(run).start();
    }
}

结果：
2. 有参数的基本格式（无参数也是类似，基本格式不变）：

 class test {
    public static void main(String[] args) {
    //先写括号填参数，标箭头，写内容；
        ThLambda thLambda = (String s) -> {
            System.out.println(s);
        };
        thLambda.test("这就是演示；");
    }
}

interface ThLambda {
    void test(String s);
}

2. 函数式接口

就是指接口只有一个抽象方法；这个接口使用了注解@FunctionalInterface，可以通过Lambda表达式来创建接口的对象；java 8中的函数式接口定义在包java.util.function中；

3. 方法引用与构造器引用

方法引用

class test {
    public static void main(String[] args) {
        /*方法引用,
         *方法一：  对象 :: 非静态方法
         * 方法二： 类 :: 静态方法
         * 方法三： 类 :: 非静态方法
         */
        PrintStream out = System.out;
        Consumer<String> con = out::println;
        con.accept("I am x");
    }
}

运行结果：
基本的函数式接口：

接口名	抽象方法及用途	参数	返回类型
Consumer<T>	accept()，给入参数，没有返回值	T	void
Supplier<T>	get()，没有参数，但有返回值	无	T
Function<T,R>	R apply(T t),对参数T进行处理，返回R型结果	T	R
Predicate<T>	boolean test(T t),确定类型T的对象是否满足某些条件，并且返回boolean值	T	boolean

构造器引用
和方法的引用使用类似，主要使用就是：类::new
数组引用
将数组看成一个特殊的类即可，使用方式与构造器引用一样；

4. StreamAPI

创建StreamAPI总共有四种方式：
通过集合创建：

        //第一种创建方式：通过集合创建
    /*其中Employees是我创建的一个类，employeedatas()是它的static方法；*/
    List<Employees> list = Employees.employeedatas();
    //创建一个顺序流
    Stream<Employees> stream1 = list.stream();
    //创建一个并行流，就像是多线程一样，不一定按顺序进行；
    Stream<Employees> stream2 = list.parallelStream();

通过数组创建：

     //Employees[] arr =new Employees[] {new Employees(1, "dao"), new Employees(2, "sdd")};
    //上面的数组和下面的数组是一样的；
    Employees[] arr =  {new Employees(1, "dao"), new Employees(2, "sdd")};
    //通过数组创建
    Stream<Employees> stream = Arrays.stream(arr);

通过Stream的of创建

      Employees dao = new Employees(1, "dao");
    Employees sdd = new Employees(2, "sdd");
    //通过of直接创建；
    Stream<Employees> dao1 = Stream.of(dao, sdd);

第四种：创建无限流
通过Stream.iterare()和Stream.generate()方法创建；

5. Optional类

Optional类（java.util.Optional）是一个容器类，主要就是用来存放一些类的值，而且值可以为null；

    //创建一个非空的实例,必须为非空
    Optional<Employees> o = Optional.of(new Employees(1, "dak"));
    //创建一个空的
    Optional o2 = Optional.empty();
            //先创建一个Optional实例
    Optional<Employees> o = Optional.ofNullable(e);

基本理解

    public String test5(Employees e) {
    //没有用Optional时的写法；
    /*if(e!=null){
        return "not null";
    }
    return null;*/
    //先创建一个Optional实例
    Optional<Employees> o = Optional.ofNullable(e);
    //万一这个e为空怎么办；可以先用预备一个不是空的对象放入，作为备选；
    Employees s = o.orElse(new Employees(1, "神"));
    //这样返回的就不会报空指针异常；
    return s.getName();
}