Java 1.8 新特性

Posted 2022-05-24 xfdhh

Lambda表达式

1、本质上是对匿名内部类对象的一种格式的简化

2、Lambda运算符 "->"，也称箭头运算符，作用 分隔前后两部分

3、运算符左边是Lambda的参数列表（接口中定义的抽象方法的参数）

　　右边是Lambda的方法体

4、语法格式：

　　1、没有参数和返回值  () -> System.out.println(“Hello Lambda”);

　　2、有一个参数，没有返回值 (x)-> System.out.println(x * x);  当只有一个参数时，参数的括号可以省略

　　3、有多个参数，没有返回值，格式和语法格式2相同 (x, y) -> System.out.println(x + y);

　　4、接口中需要重写的方法，方法内容有多句，需要给多句话加上大括号　

　　　　(x, y) -> int result = x + y; return result;

　　　　如果Lambda体中语句只有一句，那么大括号可以省略不写；如果大括号中只有一条语句，并且是return语句，

　　那么return关键字也可以省略不写（如果要省略return关键字，就必须省略大括号）

  　　　　例如：(x, y) -> x + y

函数式接口

1、Lambda表达式使用的前提，就是接口必须是一个函数式接口

2、如果在接口中，只有一个抽象方法，那么这个接口就是函数式接口

3、使用注解来检查当前接口是否是一个函数式接口

    @FunctionalInterface   　　如果不是函数式接口，则编译报错

4、本质： 

　　想表达的是一个方法的内容，由于方法不在任何类中，所以称为函数

　　接口其实想表达的就是一个函数的声明

　　将来使用这个接口的实现类对象，来表达一个函数的实现

　　Java中不支持将函数作为一个数据，也就不能将这个函数进行各种传递，也就不能作为对象的成员变量存在

　　只能在方法外加一层接口的声明，将来可以传递方法所在接口的实现类对象，来间接的传递方法内容

5、常用内置函数式接口

　　1.8中提供了一些常用的函数式接口，在使用类似功能的时候，不需要额外定义接口，直接使用jdk中提供的即可。　　

　　Consumer<T>：消费型接口

   　　　void accept(T t);

　　Supplier<T>：供给型接口

　　　　T get();

　　Function<T, R>：函数型接口

　　　　R apply(T t);

　　Predicate<T>：断言型接口

　　　　boolean test(T t)

6、方法的引用

　　1、写一个函数式接口时，方法的实现（lambda体），已经被某个其他的对象实现了，就不需要在Lambda体中，再次调用这个实现，而可以直接使用那个已经定义好的方法。

　　2、格式：

  　　　　函数式接口 名称 = 对象名 :: 方法名称

  　　　　函数式接口 名称 = 类名 :: 静态方法名

　　3、作用：

 　　　　 把已经实现的方法，作为一个数据，作为一个引用，赋值给某个函数式接口的引用

  　　　　可以把这个引用当做方法的返回值，也可以作为方法的实际参数进行传递

　　4、本质：

  　　　　可以把任意一个方法，作为函数式接口的一个实现类对象

方法的引用

7、消费型接口 Consumer<T>

　　抽象方法：void accept(T t);

　　某个函数可以接收一个数据，并且处理这个数据，处理完成之后，不需要返回任何数据，这个函数需要当做数据来进行传递，就使用消费型接口。

import java.util.function.Consumer;

public class Test4 

    public static void main(String[] args) 
        Consumer<String> con = x->System.out.println(x);
        test(998,con,"大宝剑");
    
    public static void test(int money,Consumer<String> con,String str) 
        //只需要处理数据，不需要返回值Consumer<T>
        System.out.println("花了"+money+"块钱");
        con.accept(str);
    

消费型接口

8、供给型接口 Supplier<T>

　　抽象方法：T get()

　　如果需要定义函数，可以生产一个需要的数据，这个函数需要当做数据来进行传递，那么就可以使用供给型接口。

　　以前我们只能传递数据，现在可以传递生产数据的方式。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;

public class Test6 

    public static void main(String[] args) 
        Random r = new Random();
        //在参数中定义Lambda函数体
        List<Integer> list = getNum(10,()->r.nextInt(30)+21);
        System.out.println(list);

    
    public static List<Integer> getNum(int n,Supplier<Integer> sup)
        List<Integer> list = new ArrayList<Integer>();
        for(int i=1;i<=n;i++) 
            list.add(sup.get());//供给对象调用get()方法获取生成的数据
        
        return list;    
    

供给型接口

9、函数型接口 Function<T, R>

　　抽象方法：R apply(T t)　　

　　如果需要定义一个函数，接收一个数据，将数据进行处理，完成之后，还能返回一个结果，就可以使用函数型接口

　　以前我们只能传递处理好之后的数据，或者将原始数据传入方法

　　现在可以传入原始数据，并且还可以传入处理方式

import java.util.function.Function;

public class Test7 

    public static void main(String[] args) 
        Function<String,Integer> fun = x->Integer.parseInt(x);
        int num = parse("555",fun);
        System.out.println(num);
        
        Function<Integer,Integer> fun1 = x->x*x;
        int result = method(6,fun1);
        System.out.println(result);
        
        int result1 = method01("5",Integer::parseInt,x->x*x);
        System.out.println(result1);
    
    public static int method01(String str,Function<String,Integer> fun,Function<Integer,Integer> fun1) 
        //andThen()先执行前面的方法，再执行后面的方法，apply()给函数接口传参
        return fun.andThen(fun1).apply(str);
    
    
    public static int method(int i,Function<Integer,Integer> fun) 
        return fun.apply(i);    
    
    public static int parse(String str,Function<String,Integer> fun)
        return fun.apply(str);
    

函数式接口

10、断言型接口 Predicate<T>

　　抽象方法：boolean test(T t)

　　如果需要定义一个函数，接收一个数据，判断数据是否合法，返回一个boolean结果，就可以使用断言型接口

　　以前我们只能传入处理好的数据到方法中

　　现在可以将原始数据传入，将过滤的条件也传入

import java.util.ArrayList;
import java.util.function.Predicate;

public class Test8 

    public static void main(String[] args) 
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(66);
        list.add(666);
        list.add(35);
        list.add(-20);
        list.add(0);
        list.add(33);
        
        ArrayList<Integer> odds = filt(list, x -> x % 2 == 0);
        System.out.println(odds);
        
        ArrayList<Integer> oddsNeg = filt(odds, x -> x < 0);
        System.out.println(oddsNeg);
        
        ArrayList<Integer> oddsNegS = filt(list, x -> x % 2 == 0, x -> x < 0);
        System.out.println(oddsNegS);
        
        //获得list中大于100的数字或者是偶数
        ArrayList<Integer> results = filtOr(list, x -> x > 100, x -> x % 2 == 0);
        System.out.println(results);
        //取反  非偶数
        ArrayList<Integer> testNeg = filtNeg(list, x -> x % 2 == 0);
        System.out.println(testNeg);
    
    

    

    public static ArrayList<Integer> filt(ArrayList<Integer> list, Predicate<Integer> pre) 
        ArrayList<Integer> result = new ArrayList<>();
        for (int  i : list) 
            if (pre.test(i)) //断言型接口的对象.test()进行判断
                result.add(i);
            
        
        return result;
    

    public static ArrayList<Integer> filt(ArrayList<Integer> list, Predicate<Integer> pre1, Predicate<Integer> pre2) 
        ArrayList<Integer> result = new ArrayList<>();
        for (int  i : list) 
            if (pre1.and(pre2).test(i)) //and()同时满足
                result.add(i);
            
        
        return result;
    

    public static ArrayList<Integer> filtNeg(ArrayList<Integer> list, Predicate<Integer> pre) 
        ArrayList<Integer> result = new ArrayList<>();
        for (int  i : list) 
            if (pre.negate().test(i)) //negate()相当于非 !
                result.add(i);
            
        
        return result;
    

    public static ArrayList<Integer> filtOr(ArrayList<Integer> list, Predicate<Integer> pre1, Predicate<Integer> pre2 ) 
        ArrayList<Integer> result = new ArrayList<>();
        for (int  i : list) 
            if (pre1.or(pre2).test(i)) //or只要满足其中一个条件
                result.add(i);
            
        
        return result;
    

断言型接口