【jdk1.8的新特性】

学习内容：

1. lambda表达式
2. 函数式接口
3. 方法引用
4. stream流式编程

---

学习产出：

lambda表达式

Lambda适用于只有一个抽象方法的接口

第一种无参数无返回值

public interface MyInterfaceA {
    //接口中的方法默认是抽象方法，public abstract修饰
     void test();
}
        //无参数无返回值
        //简化写法，只有一行代码可以使用简化写法
        MyInterfaceA a=()-> System.out.println("aaa");
        a.test();
        //常规方法
        a=()->{
            System.out.println("bbb");
            System.out.println("ccc");
        };
        a.test();

单参无返回值

public interface MyInterfaceA {
    //接口中的方法默认是抽象方法，public abstract修饰
     void test(String userName);
}
        MyInterfaceA myInterfaceA=(String a)->{
            System.out.println(a+a);
        };
        myInterfaceA.test("aaa");
        //类型可以省略
         MyInterfaceA myInterfaceB=(a)->{
            System.out.println(a+a);
        };
         //参数的括号可以省略
        MyInterfaceA myInterfaceC=a->{
            System.out.println(a+a);
        };
       

多参无返回值

public interface MyInterfaceA {
    //接口中的方法默认是抽象方法，public abstract修饰
     void test(String userName,String passWord);
}
		//多参数，参数括号不能省略
 		MyInterfaceA myInterfaceA=(a,b)->{
            System.out.println(a+b);
    };

无参有返回值

public interface MyInterfaceA {
    //接口中的方法默认是抽象方法，public abstract修饰
     String test();
}
		MyInterfaceA myInterfaceA=()->{
            System.out.println("aaa");
            return "aaa" ;
        };
    	//简化写法，只有一行代码的时候，可以省略return和花括号
        MyInterfaceA myInterfaceB=()-> "aaa";

剩下的可以依据上面的类推

---

函数式接口

函数式接口：接口中只能有一个抽象方法，其他的可以有default，static，Object里面继承的方法
作用：在Java中主要用在Lambda表达式和方法引用（想要使用Lambda表达式，接口必须是函数式接口）
jdk8提供了@FunctionalInterface，来对函数式接口进行检查

内置的函数式接口

消费型接口：void accept（T t） 有参数（单参）无返回值

 ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
        list.forEach((Integer integer)->{
            System.out.println(integer*10);
        });
        list.forEach(x -> System.out.println(x*10));

供给型接口：T get() 无参数有返回值

Supplier<String> supplier=new Supplier<String>() {
            @Override
            public String get() {
                return people.getName();
            }
        };

函数型接口：R apply(T t) 有
断言型接口：

//
 		Predicate<Integer> predicate=a->{
          if (a<10)return false;
          return true;
        };
        //为true的会删掉
        boolean b = list.removeIf(a->{
            if (a<10)return false;
            return true;
        });

---

方法引用

方法引用符号 ::

public class People {
    String name;
    String age;
    //get,set方法省略
 }


 		Consumer<Integer> consumer=x-> System.out.println(x);
        Consumer<Integer> consumer1=System.out::println;
        consumer.accept(1);
        consumer.accept(2);

list.forEach(System.out::println);

Supplier<String> supplier1=people::getName;

Comparator<Integer> comparator=(x,y)->Integer.compare(x,y);
Comparator<Integer> comparator1=Integer::compare;

---

stream流式编程

给程序员提供了一堆处理数据的方法

//这里要注意的是coun(),foreach都属于结束操作，具体的建议百度
	ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,3,45,76,3,2,354,435,6);
        Stream<Integer> stream = list.stream();

        Stream<Integer> stream1 = stream.filter(x -> {
            return x > 45;
        }).distinct().sorted(Integer::compare).limit(3);

        //stream1.forEach(x-> System.out.println(x));

        stream1.forEach(System.out::println);

上面的多个中间操作连在一起，叫做串行流
还有一个并行流

---

Optional

主要目的是为了避免空指针异常的发生

        //如果传入的参数是空，会抛空指针异常
        //Optional people1 = Optional.of(people);
        //传递的参数为空，创建Optional对象
        Optional<People> people2 = Optional.ofNullable(people);
         //如果对象不为空，orElse还是会创建对象
        People people1 = Optional.ofNullable(people).orElse(new People());
        //如果对象不为空，ofNullable不会创建对象
        People people2 = Optional.ofNullable(people).orElseGet(()->new People());