Java8新特性（基础篇）

Java8其他特性

目录：

• Lambda表达式
• 函数式接口
• 方法引用与构造器引用
• StreamAPI
• Optional类

Lambda表达式（详细内容翻以前的博客）

public class DemoLambda {
    public static void main(String[] args) {
        Calculate calculate =(a,b) -> a+b;
     int a = calculate.add(1231,1231);
        System.out.println(a);
    }
}
interface Calculate{
        int add(int a,int b);
}

-> : Lamda的操作符

箭头左边：Lambda形参列表–即接口中抽象方法的形参列表

箭头右边：Lambda体，重写的抽象方法的方法体

函数式接口

如果一个接口只声明了一个抽象方法，则此接口就是函数式接口

Lambda表示的本质就是函数式接口的实例

Java4大内置核心函数式接口

消费型接口	Consumer	void accept(T t)
供给型接口	Supplier	T get( )
函数型接口	Function<T,R>	R apply( T )
断定型接口	Predicate	boolean test( T t)

方法引用与构造器引用

方法引用使用情景：当要传递给Lambda体的操作，已经有实现的方法时，可以使用方法引用

方法引用本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例，所以方法引用也是函数式接口的实例

使用格式：类或对象 ：：方法名

要求：接口中的形参列表和方法引用的形参列表完全相同(不适用类调实例方法)

• 对象：：非静态方法

  Consumer<String> con1 = str -> System.out.println(str);//Lambda
  
  //方法引用
  PrintStream ps = System.out;
  Consumer<String> con2 = ps::println;
  con2.accept(666);
  

• 类：：非静态方法

  //Comparator中的int  compare（T t1,T t2）
  //String 中的int     t1.compareTo(t2)
  
  Comparator<String> com1 = (t1,t2) ->t1.compareTo(t2);
  sout.(com1.compare(t1,t2));
  //方法引用
  Comparator<String> com2 = String::compareTo;
  sout.(com2.compare(a,b));
  
  //=======//
    //BiPredicate中的boolean test(T t1,T t2)
          //String 中的boolean a.equals(b);
          BiPredicate<String,String> bb = (s1,s2) -> s1.equals(s2);
          System.out.println(bb.test("a","BB"));
          //方法引用
          BiPredicate<String,String> bb2 = String::equals;
          System.out.println(bb2.test("A","B"));
  
  
  

• 类：：静态方法

  Comparator<Integer> com1 = (a,b) -> Integer.compare(a,b);//Lambda
  
  //方法引用
  Comparator<Integer> com2 = Integer::compare;
  
  

构造器引用

与上文类似

StreamAPI(后续专门出一篇)

Stream的操作三个步骤

1. 创建Stream
2. 中间操作
3. 终止操作（终端操做）

• Stream关注的是对数据的运算，与CPU打交道
• 集合关注的是数据的存储，与内存打交道
• Stream自身不会存储元素
• Stream不会改变源对象，相反，他们会返回一个持有结果的新Stream
• Stream操作是延迟的，这意味着他们会等到需要结果时才执行

创建Stream方式

1. 集合
2. 数组
3. 通过Stream的of（）
4. 创建无限流

中间操作

1. 筛选与切片
2. 映射
3. 排序

Optional类

为解决空指针问题

1.理解：为了解决java中的空指针问题而生！
Optional<T> 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null
，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避
免空指针异常。

2.常用方法：
@Test
    public void test1(){
        //empty():创建的Optional对象内部的value = null
        Optional<Object> op1 = Optional.empty();
        if(!op1.isPresent()){//Optional封装的数据是否包含数据
            System.out.println("数据为空");

        }
        System.out.println(op1);
        System.out.println(op1.isPresent());
        //如果Optional封装的数据value为空，则get()报错。否则，value不为空时，返回value.
//        System.out.println(op1.get());

    }

    @Test
    public void test2(){
        String str = "hello";
//        str = null;
        //of(T t):封装数据t生成Optional对象。要求t非空，否则报错。
        Optional<String> op1 = Optional.of(str);
        //get()通常与of()方法搭配使用。用于获取内部的封装的数据value
        String str1 = op1.get();
        System.out.println(str1);

    }

    @Test
    public void test3(){
        String str = "beijing";
        str = null;
        //ofNullable(T t) ：封装数据t赋给Optional内部的value。不要求t非空
        Optional<String> op1 = Optional.ofNullable(str);
        //orElse(T t1):如果Optional内部的value非空，则返回此value值。如果
        //value为空，则返回t1.
        String str2 = op1.orElse("shanghai");

        System.out.println(str2);//


    }

3.典型练习：
能保证如下的方法执行中不会出现空指针的异常。
//使用Optional类的getGirlName():
public String getGirlName2(Boy boy){

    Optional<Boy> boyOptional = Optional.ofNullable(boy);
    //此时的boy1一定非空
    Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));

    Girl girl = boy1.getGirl();

    Optional<Girl> girlOptional = Optional.ofNullable(girl);
    //girl1一定非空
    Girl girl1 = girlOptional.orElse(new Girl("古力娜扎"));

    return girl1.getName();
}

@Test
public void test5(){
    Boy boy = null;
    boy = new Boy();
    boy = new Boy(new Girl("苍老师"));
    String girlName = getGirlName2(boy);
    System.out.println(girlName);

}