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. 方法引用与构造器引用

1. 方法引用

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

2. 构造器引用
   和方法的引用使用类似，主要使用就是： 类::new

3. 数组引用
   将数组看成一个特殊的类即可，使用方式与构造器引用一样；

4. StreamAPI

1. 创建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类

1. 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);
   

2. 基本理解

       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();
   }