Lambda表达式使用介绍

33次阅读

共计 7630 个字符，预计需要花费 20 分钟才能阅读完成。

写在前面

本文主要是简单介绍 Lambda 表达式和函数式接口的使用方法，并不涉及原理，希望初学者看完之后可以在日常开发中灵活运用 Lambda 表达式编程

Lambda 的特性

Java 8 增加了一个全新语言级别的功能，称为 Lambda 表达式。允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理存储在变量中

Lambda 表达式语法

Lambda 表达式由参数列表和方法体组成：`(type1 arg1,type2 arg2,...) -> {body;};` 参数之间用 `,` 分隔
  • 1、没有入参时，用 （） 空括号表示。如：() -> {body};

  • 2、入参只有一个时，可以有两种表示方式：

      1) (String s) -> {body};
  2)s -> {body}; 省略了参数的类型，Lambda 会根据上下文推断出参数类型，并且不需要括号包围

  • 3、有多个入参时：(String name,int age,boolean flag) -> {body}

       也可以省略参数类型直接写成这样：`(name,age,flag) -> {body}` 参数列表必须有 `()` 包围
  • 4、当方法体只有一条语句时，可以省略{}。如：() -> System.out.println("hello world"); 
 - 一些例子：1、()-> System.out.println("Lambda 表达式");
2、(String s) -> System.out.println(s);
3、s -> return s;

4、(String s,int num) -> {if(num >= 10){return s.toUpperCase();
    }
    return s.toLowerCase();};
5、(age,name,flag) -> 42;

Lambda 表达式不能单独使用，需要绑定函数式接口才能使用

函数式接口

函数式接口 (Functional Interface) 是 Java 8 对一类特殊类型的接口的称呼。这类接口抽象方法的数量只有一个，并且使用了 @FunctionalInterface 进行注解。需要注意的是，只有一个抽象方法的接口，即使没有 @FunctionalInterface 进行注解，编译器也会把它当作函数式接口。

特殊的是 java.util.Comparator<T> 接口具有两个抽象方法，如下：

int compare(T o1, T o2);
boolean equals(Object obj);

但它仍然是函数式接口，为什么呢？

如果接口声明了一个覆盖 java.lang.Object 公共方法的抽象方法，那么这个方法不会计入接口的抽象方法计数中，因为该接口的任何实现都将具有来自 java.lang.Object 或其他地方的针对于该方法的实现。java.util.Comparator<T> 接口中的 equals(Object obj)方法是 java.lang.Object 中的一个 public 方法的声明，不在抽象方法的计数中

实际上 Lambda 表达式就是对函数式接口中唯一的抽象方法的实现，所以 Lambda 表达式的参数需要和函数式接口抽象方法的参数列表一致。

在 jdk8 中，引入了一个新的包 java.util.function, 提供了一系列的函数式接口，这个包中的接口大致可以分为以下四类：
Function<T,R>: 接收参数，并返回结果，抽象方法为 R apply(T t)
Consumer<T>: 接收参数，无返回结果, 抽象方法为 void accept(T t)
Supplier<T>: 不接收参数，但返回结果，抽象方法为 T get()
Predicate<T>: 接收参数，返回 boolean 值，抽象方法为 boolean test(T t)

可以根据需要选择不同的函数式接口，不需要每次自定义函数式接口使用

Lambda 表达式和函数式接口的实例应用

1、获得函数式接口的实例对象，进行方法的调用

// 自定义函数式接口
@FunctionalInterface
public interface TestFunctionInterface {
    // 函数式接口的唯一抽象方法，需要 Lambda 表达式实现
    String testFunction(String a,int b);
    
}

// 测试类
public class Client {public static void main(String[] args) {
      // 使用 Lambda 表达式实现 TestFunctionInterface 的抽象方法，并且得到实例对象
      TestFunctionInterface testFunctionInterface = (String name,int age)->{if(age==10){return name.toUpperCase();
      }
      return "NO NAME!";
    };

    // 通过 testFunctionInterface 调用 testFunction()方法并传入参数，得到返回的结果 result
    String result = testFunctionInterface.testFunction("David",10);
    System.out.println(result);

    }

}


打印结果：DAVID

----------
2、函数式接口作为某个方法的参数使用

// 自定义函数式接口
@FunctionalInterface
public interface TestFunctionInterface {
    // 函数式接口的唯一抽象方法，需要 Lambda 表达式实现
    String testFunction(String a,int b);
    
}


// 测试类
public class Client {public static void main(String[] args) {
        // 调用 test 方法
        test("steven",20,(name,age) -> {if(age==10){return name.toUpperCase();
            }
            return "NO NAME!";
            }
        );

    }
    
    // 函数式接口对象作为参数的方法
    public static void test(String name,int age,TestFunctionInterface testFunctionInterface){String result = testFunctionInterface.testFunction(name,age);
        System.out.println(result);
    }

}

打印结果：NO NAME!

特别注意：以上两种方法使用 Lambda 表达式时，Lambda 的参数和返回值必须要和函数式接口的抽象方法保持一致

方法引用

Lambda 表达式使用 :: 来调用特定的已存在方法作为函数式接口唯一抽象方法的实现，可以使代码更具可读性

1. 静态方法

Lambda :(arg0,arg1,arg2,…) -> ClassName.staticMethod(arg0,arg1,arg2,…)
方法引用：ClassName::staticMethod

`TestStaticMethod::testStaticMethod` 即调用 `TestStaticMethod` 的静态方法 `String testStaticMethod(int age,boolean flag)` 作为函数式接口抽象方法的实现，调用的方法的参数类型和返回值需要和抽象方法保持一致
@FunctionalInterface
public interface TestFunctionInterface {String testFunction(int i);

}

public class TestStaticMethod {public static String testStaticMethod(int age,boolean flag){if(age >10 && flag){return "SUCCESS";}

        return "ERROR";
    }
}


public class Client {public static void main(String[] args) {//TestStaticMethod::testStaticMethod 相当于 Lambda 表达式：(int age,boolean flag) -> TestStaticMethod.testStaticMethod(age,flag); 会将 Lambda 的参数按顺序传入调用的方法中，类型不匹配会报错
        TestFunctionInterface testFunctionInterface = TestStaticMethod::testStaticMethod;
        String result = testFunctionInterface.testFuction(26,true);
        System.out.println(result);


    }

}


打印结果：SUCCESS

2. 指向任意类型的实例方法引用

Lambda:(arg0,arg1,arg2,…) -> arg0.instanceMethod(arg1,arg2,…)
方法引用：ClassName.instanceMethod (注意:arg0 是 ClassName 类型的对象) 

/**
    1) 函数式接口抽象方法只有一个参数
*/
@FunctionalInterface
public interface TestFunctionInterface {int testFuction(String s);

}


public class Client {public static void main(String[] args) {// 方法引用：String::length 等价于 Lambda 表达式:(arg0) -> arg0.length()
        // 实际上调用参数对象 arg0 的 length()方法作为抽象方法的方法体实现，arg0.length()的返回值作为抽象方法的返回值 
        TestFunctionInterface testFunctionInterface = String::length;
        System.out.println(testFunctionInterface.testFuction("king"));
    }

}

打印结果：4

/**
    2) 函数式接口抽象方法有多个参数
*/
@FunctionalInterface
public interface TestFunctionInterface {int testFuction(TestMethodRef testMethodRef, String name, int age);

}

public class TestMethodRef {public int testMethodRef(String name,int age){return name.length()+age;
    }
}

public class Client {public static void main(String[] args) {//TestMethodRef::testMethodRef 等价于 (arg0,arg1,arg2) -> arg0.testMethodRef(arg1,arg2)
        // 编译器只会调用第一个参数 arg0 的 testMethodRef(arg1,arg2)方法，并且把余下的 arg1,arg2 按原来的顺序作为参数传入该方法中，类型不匹配会报错
        TestFunctionInterface testFunctionInterface = TestMethodRef::testMethodRef;
        int result = testFunctionInterface.testFuction(new TestMethodRef(),"king",12);
        System.out.println(result);

    }

}

打印结果：16


3. 指向现有对象的实例方法引用
@FunctionalInterface
public interface TestFunctionInterface {char testFuction(int index);

}

public class Client {public static void main(String[] args) {
        String content="hello";
        //content::charAt 等价于 (int index) -> content.charAt(index);
        TestFunctionInterface testFunctionInterface = content::charAt;
        System.out.println(testFunctionInterface.testFuction(0));
    }

}    

打印结果：h

Stream API

java.util.stream.Stream 接口 和 Lambda 表达式一样，都是 Java 8 新引入的。所有 Stream 的操作必须以 Lambda 表达式为参数。Stream（流）是一个来自数据源的元素队列并支持聚合操作, 它将处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作 (terminal operation) 得到前面处理的结果，这里简单介绍一下常用的 Stream API

  • forEach 提供对 stream 流元素的迭代功能
public class Client {public static void main(String[] args) {List<Info> list = new ArrayList<>();
        list.add(new Info("first", 1));
        list.add(new Info("second", 2));
        list.add(new Info("third", 3));
        list.add(new Info("four", 4));
        list.add(new Info("five", 5));
        //list.stream()创建 Stream 流，调用 forEach 打印所有的 name
        list.stream().forEach(t->System.out.println(t.name));
    }

}
打印结果：first
second
third
four
five
  • filter 设置过滤限制

public class Client {public static void main(String[] args) {List<Info> list = new ArrayList<>();
        list.add(new Info("first", 1));
        list.add(new Info("second", 2));
        list.add(new Info("third", 3));
        list.add(new Info("four", 4));
        list.add(new Info("five", 5));
        // 针对 age 进行过滤
        list.stream().filter(t->t.age>3).forEach(t->System.out.println(t.name));
    }

}


打印结果：four
five
  • map 将流元素映射到不同的结果
public class Client {public static void main(String[] args) {List<Info> list = new ArrayList<>();
        list.add(new Info("first", 1));
        list.add(new Info("second", 2));
        list.add(new Info("third", 3));
        list.add(new Info("four", 4));
        list.add(new Info("five", 5));
        // 将 Info 对象映射成 String 对象
        List<String> names=list.stream().map(t->t.name).collect(Collectors.toList());
    }

}
  • limit 获取指定数量的流元素
Stream.of(1,2,3,4,5,6,7).limit(3).forEach(System.out::println);
打印结果：1
2
3
  • skip 忽略指定数量的流元素
// 忽略前 4 个流元素
Stream.of(1,2,3,4,5,6,7).skip(4).forEach(System.out::println);

打印结果：5
6
7
  • sorted 对流进行排序
public class Client {public static void main(String[] args) {List<Info> list = new ArrayList<>();
        list.add(new Info("first", 1));
        list.add(new Info("second", 2));
        list.add(new Info("third", 3));
        list.add(new Info("four", 4));
        list.add(new Info("five", 5));
        list.stream().sorted(new Comparator<Info>() {
            @Override
            // 根据 age 降序排列
            public int compare(Info o1, Info o2) {return o2.age-o1.age;}
        }).forEach(t->System.out.print(t.name+" "));
    }

}

打印结果：five four third second first
  • findFirst 返回第一个元素
//findFirst()返回 Optional 对象，需要调用 Optional.get()方法获取值
int value=Stream.of(1,2,3,4,5,6,7).findFirst().get();
System.out.println(value);

打印结果：1
  • anyMatch 匹配任意一个就返回 true
//stream 流中只要有一个元素的值等于 2，就返回 true
boolean value=Stream.of(1,2,3,4,5,6,7).anyMatch(t->t==2);
System.out.println(value);

打印结果：true
  • allMatch 匹配所有元素才返回 true
//stream 流中所有元素的值都等于 2，才返回 true
boolean value=Stream.of(1,2,3,4,5,6,7).allMatch(t->t==2);
System.out.println(value);

打印结果：false
  • collect 将 Stream 转换为集合
List list=Stream.of(1,2,3,4,5,6,7).collect(Collectors.toList());
Set set = Stream.of(1,2,3,4,5,6,7).collect(Collectors.toSet());

最后

希望大家在开发中可以多使用 Lambda 表达式、函数式接口和 Stream API，真的很方便并且效率更高。

正文完
发表至： java
2019-09-26
 0
做IT这几年我整理了这些干货想要送给你
Spring-Boot整合MyBatis
关于java:ConfigurationClassPostProcessor
IDEA设置后端代码开发规范