Java8新特性——Lambda表达式的使用

墨蓝 2021-07-24 22:41 413阅读 1赞

# 1、Lambda表达式的简介 #

Java8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口。

Lambda 表达式（Lambda Expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的Lambda抽象（Lambda Abstraction），是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

**【示例】**下面这个例子是使用Lambda表达式的简单示例，代码不仅简洁，而且还可读。

/**
     * Lambda表达式的使用
     * @author pan_junbiao
     */
    @Test
    public void simpleTest()
    {
        //1、使用传统方式创建线程
        Thread thread1 = new Thread(new Runnable()
        {
            //重写run()方法
            @Override
            public void run()
            {
                System.out.println("线程启动（使用传统方式）");
            }
        });
        thread1.start();
    
        //2、使用Lambda表达式创建线程
        Thread thread2 = new Thread(()->System.out.println("线程启动（使用Lambda表达式）"));
        thread2.start();
    }

**执行结果：**

![20200502100353729.jpg][]

# 2、Lambda表达式的语法 #

Lambda表达式的语法如下：

() -> {}

Lambda的语法定义，它由三部分组成：

**参数列表：**Lambda表达式的参数列表，参数的类型可以省略，因为编译器会根据方法体中的参数来确定类型。

**操作符（->）：**Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或Lambda操作符。

**代码块：**Lambda表达式中所需执行的功能， 即Lambda方法体，如果代码块只有一条语句时可以将“\{\}”省略；如果只有一条return语句，那么“return”可以省略。

Lambda表达式本质上是一个匿名方法。让我们来看下面这个例子：

public int add(int x, int y) {
        return x + y;
    }

转成Lambda表达式：

(int x, int y) -> x + y;

参数类型也可以省略，因为编译器会根据方法体中的参数来确定类型：

(x, y) -> x + y;

或者：

(x, y) -> { return x + y; } //显式指明返回值

## 2.1 无参数，无返回值 ##

/**
     *  无参数，无返回值
     *  @author pan_junbiao
     */
    @Test
    public void test1()
    {
        Runnable runnable = ()->System.out.println("线程启动");
        runnable.run();
    }

**执行结果：**

![20200502105838795.jpg][]

## 2.2 有参数，无返回值 ##

/**
     *  有参数，无返回值
     *  @author pan_junbiao
     */
    @Test
    public void test2()
    {
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("您好，欢迎访问 pan_junbiao的博客");
    }

**执行结果：**

**![20200502110425553.jpg][]**

## 2.3 无参数，有返回值 ##

/**
     *  无参数，有返回值
     *  @author pan_junbiao
     */
    @Test
    public void test3()
    {
        Supplier<String> supplier = ()->"您好，欢迎访问 pan_junbiao的博客".substring(8, 22);
        System.out.println(supplier.get());
    }

**执行结果：**

![20200502112007324.jpg][]

## 2.4 有一个参数，有返回值 ##

/**
     *  有一个参数，有返回值
     *  @author pan_junbiao
     */
    @Test
    public void test4()
    {
        Function<String, String> function = (s)->s.substring(8, 22);
        System.out.println(function.apply("您好，欢迎访问 pan_junbiao的博客"));
    }

**执行结果：**

![20200502112318794.jpg][]

## 2.5 有两个参数，有返回值 ##

/**
     *  有多个参数，有返回值
     *  @author pan_junbiao
     */
    @Test
    public void test5()
    {
        BiFunction<String,String,String> biFunction = (String s1, String s2) -> s1.concat(s2);
        System.out.println(biFunction.apply("您好，欢迎访问 ","pan_junbiao的博客"));
    }

**执行结果：**

**![2020050211444937.jpg][]**

# 3、函数式接口 #

Lambda表达式的目标类型必须是“函数式接口（functional interface）”。函数式接口：只包含一个抽象方法的接口。接口可以包含多个默认方法、类方法，但关键是一个抽象方法。所谓函数式接口，指的是只有一个抽象方法的接口。函数式接口可以被隐式转换为Lambda表达式。函数式接口可以用@FunctionalInterface注解标识。

## 3.1 自定义函数式接口 ##

Java 8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。@FunctionalInterface 就是用来指定某个接口必须是函数式接口，所以 @FunInterface 只能修饰接口，不能修饰其它程序元素。

**【示例】**使用@FunctionalInterface注解自定义函数式接口，要求接受两个参数，并且有返回值。

（1）创建名称为MyFunction的函数式接口。

/**
     * 自定义函数式接口
     * @author pan_junbiao
     **/
    @FunctionalInterface
    public interface MyFunction<T, U, R>
    {
        R apply(T t, U u);
    }

（2）使用函数式接口实现数字的加法、减法、乘法、除法、字符串拼接。

/**
     *  使用自定义函数式接口
     *  @author pan_junbiao
     */
    @Test
    public void MyFunctionTest()
    {
        //加法
        MyFunction<Integer,Integer,Integer> addFunction1 = (Integer x,Integer y) -> x+y;
        System.out.println("加法执行结果：" + addFunction1.apply(3,5));
    
        //减法
        MyFunction<Integer,Integer,Integer> subFunction1 = (Integer x,Integer y) -> x-y;
        System.out.println("减法执行结果：" + subFunction1.apply(10,4));
    
        //乘法
        MyFunction<Integer,Integer,Integer> mulFunction1 = (Integer x,Integer y) -> x*y;
        System.out.println("乘法执行结果：" + mulFunction1.apply(20,5));
    
        //除法
        MyFunction<Integer,Integer,Integer> divFunction1 = (Integer x,Integer y) -> {
            //被除数不能为0
            if(y==0)
            {
                return 0;
            }
    
            return x/y;
        };
        System.out.println("除法执行结果：" + divFunction1.apply(20,4));
    
        //字符串拼接
        MyFunction<String,String,String> strFunction = (String s1, String s2) -> s1.concat(s2);
        System.out.println("字符串拼接结果：" +strFunction.apply("您好，欢迎访问 ","pan_junbiao的博客"));
    }

**执行结果：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70][]

## 3.2 Java内置的函数式接口 ##

Java已经提供了一些函数式接口，这些接口在 java.util.function 包下，常用的函数式接口如下：

<table> 
 <thead> 
  <tr> 
   <th style="width:157px;">函数式接口</th> 
   <th style="width:134px;">参数类型</th> 
   <th style="width:140px;">返回类型</th> 
   <th style="width:368px;">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:157px;">Consumer&lt;T&gt;</td> 
   <td style="width:134px;">T</td> 
   <td style="width:140px;">无</td> 
   <td style="width:368px;">接受一个参数T，无返回结果。</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">Supplier&lt;T&gt;</td> 
   <td style="width:134px;">无</td> 
   <td style="width:140px;">T</td> 
   <td style="width:368px;">不接受任何参数，返回结果T。</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">Function&lt;T, R&gt;</td> 
   <td style="width:134px;">T</td> 
   <td style="width:140px;">R</td> 
   <td style="width:368px;">接受一个参数T，返回结果R。</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">Predicate&lt;T&gt;</td> 
   <td style="width:134px;">T</td> 
   <td style="width:140px;">boolean</td> 
   <td style="width:368px;">接受一个参数T，返回结果boolean类型。</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">UnaryOperator&lt;T&gt;</td> 
   <td style="width:134px;">T</td> 
   <td style="width:140px;">T</td> 
   <td style="width:368px;">继承自Function&lt;T, T&gt;，接受一个参数T，返回相同类型T的结果。</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">BiFunction&lt;T, U, R&gt;</td> 
   <td style="width:134px;">T, U</td> 
   <td style="width:140px;">R</td> 
   <td style="width:368px;">接受两个参数T和U，返回结果R。</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">BinaryOperator&lt;T&gt;</td> 
   <td style="width:134px;">T</td> 
   <td style="width:140px;">T</td> 
   <td style="width:368px;">继承自BiFunction&lt;T, T, T&gt;，接受两个相同类型T的参数，返回相同类型T的结果。</td> 
  </tr> 
 </tbody> 
</table>

**【示例】**使用Consumer<T>、Supplier<T>、Function<T, R>、Predicate<T>内置的函数式接口。

/**
     * 使用内置的函数式接口
     * @author pan_junbiao
     */
    @Test
    public void FunctionalInterfaceTest()
    {
        Consumer<String> consumer = (s) -> System.out.println(s);
        consumer.accept("您好，欢迎访问 pan_junbiao的博客");
    
        Supplier<String> supplier = () -> "您好，欢迎访问 pan_junbiao的博客".substring(8, 22);
        System.out.println(supplier.get());
    
        Function<String, String> function = (s) -> s.substring(8, 22);
        System.out.println(function.apply("您好，欢迎访问 pan_junbiao的博客"));
    
        Predicate<String> predicate = (s) -> {
            String userName = "pan_junbiao的博客";
            return userName.equals(s);
        };
        System.out.println(predicate.test("pan_junbiao的博客"));
    }

**执行结果：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 1][]

# 4、方法引用与构造器引用（::操作符） #

方法引用和构造器引用可以让Lambda表达式的代码在简洁的基础上再简洁，使用::双冒号来使用方法引用，看看有几种引用方式：

*  对象::实例方法名
 *  类::静态方法名
 *  类::实例方法名

//静态方法引用
    Comparator<Integer> c1 = (x, y) -> Integer.compare(x, y);
    Comparator<Integer> c2 = Integer::compare;
    
    //实例方法引用1
    userList.forEach(user -> System.out.println(user));
    userList.forEach(System.out::println);
    
    //实例方法引用2
    userList.forEach(user -> user.getName());
    userList.forEach(User::getName);
    
    //构造器引用
    strList.stream().map(s -> new String(s));
    strList.stream().map(String::new);

**【示例】**遍历用户列表。

/**
     * 遍历用户列表
     * @author pan_junbiao
     */
    @Test
    public void forEachTest()
    {
        //创建用户列表
        List<String> userList = Arrays.asList("pan_junbiao","阿标","pan_junbiao的博客","KevinPan");
    
        //遍历用户信息
        userList.forEach(System.out::println);
        //上述语句等同于如下：
        //userList.forEach(user -> System.out.println(user));
    }

**执行结果：**

![20200502175502357.jpg][]

[20200502100353729.jpg]: /images/20210724/cf43caf1a1b7409eaa01a2100a23e2af.png
[20200502105838795.jpg]: /images/20210724/26f7268c6ffe4bed9984e87e56a5b207.png
[20200502110425553.jpg]: /images/20210724/9026824cb77a4b5a9e155531e5bc9542.png
[20200502112007324.jpg]: /images/20210724/20c45f85f8e9482b84e775585e3c6318.png
[20200502112318794.jpg]: /images/20210724/6b9fd20bdcd34bfab23c70887fc64da0.png
[2020050211444937.jpg]: /images/20210724/1fba8bba1d8c4ea3b4467806a416095c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70]: /images/20210724/d4652a5f2dc84e96844a66dec54e521f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 1]: /images/20210724/337c8d7c929f4c759d7e49288dad4c13.png
[20200502175502357.jpg]: /images/20210724/4b420874b7be45fda62ac64f2111f04a.png