Lambda表达式

介绍

语法格式

(o1, o2) -> o1-o2;

(…) ：Lambda形参列表，若为空则()->{};
-> : Lambda操作符，箭头操作符
… ：Lambda体，编写系列表达式

例子

• 无参无返回值 ()->{ System.out.println(“Lambda”) }
• 只有一个参数但是无返回值 (String str)->{ System.out.println(str) }
• 参数类型省略，自动推导 (str)->{ System.out.println(str) }
• 只有一个参数，可省略括号 str->{ System.out.println(str) }
• 需要两个以上参数，多条语句有返回值

     (i, j) -> {
            System.out.println(i-j);
            return i-j;
        }

  

• 只有一条语句，return和大括号可以省略 (i,j) -> retrun i-j

函数式接口

• 若一个接口中， 只声明了一个抽象方法 ，则此接口就是 函数式接口
• 可以通过 Lambda表达式 创建该接口的实例对象

自定义函数式接口

@FunctionalInterface 用于检查该接口是否为函数式接口

 @FunctionalInterface
public interface MyInterface {
    void method();
}

  

使用

  ((MyInterface) () -> System.out.println("123")).method();

  

Java内置函数式接口

位于 java.util. Function 包下

主要四大接口

其他接口

使用

 @Test
    public  void  t2() {
        t2t("1", str -> {
            System.out.println(str + "23");
        });
    }

    public void t2t(String str, Consumer<String> consumer) {
        consumer.accept(str);
    }

    @Test
    public void t3() {
        List<String> list = new ArrayList<>();
        list.add("好的");
        list.add("好哒");
        list.add("你的");
        list.add("你哒");
        list.add("我的");
        System.out.println(t3t(list, s -> s.contains("的")));
    }

    //过滤 字符串 
    public List<String> t3t(List<String> list, Predicate<String> predicate) {
        List<String> filterList = new ArrayList<>();
        for(String s : list){
            if(predicate.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }

  

方法引用与构造器引用

方法引用

方法引用可以看做是 Lambda 表达式深层次的表达。换句话说， 方法引用就是 Lambda 表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法 。

什么时候可以使用方法引用？

• 当要传递给Lambda体的操作， 已经有实现方法了 ，可以使用方法引用
• 要求接口中的抽象方法的 形参 列表 和 返回值类型 与方法引用的方法的形参列表和返回值类型 相同 （针对前两种情况）
• 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时：ClassName::methodName （针对最后一种情况）

使用格式

使用操作符 :: 分割方法名和类或对象

• 对象::实例方法名

         Consumer<String> c1 = str -> System.out.println(str);

        PrintStream out = System.out; 
        Consumer<String> c2 = out::println;

        String str = "123";
        Supplier<Integer> s1 = () -> str.length();

        Supplier<Integer> s2 = str::length;

  

• 类::静态方法名

         Comparator<Integer> c1 = (t1, t2) ->  Integer .compare(t1, t2);
        Comparator<Integer> c2 = Integer::compare;

        Function<Double, Long> f1 = d -> Math.round(d);
        Function<Double, Long> f2 = Math::round;

  

• 类::实例方法名

         Comparator<Integer> c1 = (t1, t2) -> t1.compareTo(t2);
        Comparator<Integer> c2 = Integer::compareTo;

        BiPredicate<String, String> b1 = (s1, s2) -> s1.equals(s2);
        BiPredicate<String,  String > b2 = String::equals;

        Function<String, Integer> f1 = str -> str.length();
        Function<String,Integer> f2 = String::length;

  

构造器 和数组引用

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型

使用格式

方法引用： className ::new 数组引用： 数组的类型 [] :: new

         //构造器引用
        Supplier<String> s1 = () -> new String();
        Supplier<String> s2 = String::new;  //调用空参构造函数
        Function<char[], String> f1 = str -> new String(str);
        Function<char[], String> f2 = String::new;  //调用有参构造函数

        BiFunction<byte[],  Charset ,String> b1 = (bytes,charset) -> new String(bytes,charset);
        BiFunction<byte[], Charset,String> b2 = String::new;

        //数组引用
        Function<Integer,String[]> f3 = length -> new String[length];
        Function<Integer,String[]> f4 = Stri