【java8新特性】——lambda表达式与函数式接口详解（一）

亦凉 2023-10-02 11:13 18阅读 0赞

## 一、简介 ##

java8于2014年发布，相比于java7，java8新增了非常多的特性，如lambda表达式、函数式接口、方法引用、默认方法、新工具（编译工具）、Stream API、Date Time API、Optional等 。 当前很多公司的老产品依然使用的java7，甚至开发人员开发新产品时依然没有选择升级， 写关于java8系列文章的目的在于梳理和分享java8新增的主要特性，开发时也可以用作参考。

lambda表达式是java8新增的主要特性之一，lambda表达式又称闭包或匿名函数，主要优点在于简化代码、增强代码可读性、并行操作集合等。至于是否使用，有的同学觉得不适应，有的同学欲罢不能，见仁见智~

技多不压身，本文将采用由浅入深的方式，讲解java8 lambda表达式的语法及使用，并附带代码进行演示。

## 二、lambda语法 ##

lambda的基本语法：

(parameters) -> expression
     or
     (parameters) ->{
         statements; }

lambda表达式的特性：

1.  **可选类型声明**: 无需声明参数类型，编译器即可自动识别
2.  **可选的参数圆括号**: 仅有一个参数时圆括号可以省略
3.  **可选的大括号**：主体只包含一个语句时可省略大括号
4.  **可选的返回关键字**：主体只包含一个表达式返回值并省略大括号时，编译器会自动return返回值；有大括号时，需要显式指定表达式return了一个数值

特性示例：

//1、无参数，返回值1
    () -> 1 
    //2、无参数，无返回值
    () -> System.out.print("Java8 lambda.");
    //3、1个参数，参数类型为数字，返回值为其值的5倍
    x ->  5 * x 
    //4、2个参数，参数类型均为数字，返回值为其差值
    (x, y) -> x - y
    //5、2个参数，指定参数类型均为int型，返回值为其差值 
    (int x, int y) -> x - y  
    //6、1个参数，指定参数类型为String ，无返回值
    (String str) -> System.out.print(str)

## 三、java8 lambda使用示例 ##

前面我们讲到lambda表达式的语法和特性，那么在java8中如何使用lambda表达式呢？我们先以用几个示例来展现lambda表达式在java8中的使用。

#### 3.1 java Runnable接口的lambda实现 ####

用lambdah代替匿名类是java8中lambda的常用形式，本文以开发同学经常使用的Runnable接口匿名类为示例，演示如何用lambda表达式来代替匿名类：

1.  在java8之前：

new Thread(new Runnable()
       {
        
        @Override
        public void run()
        {
        
             System.out.println("No use lambda.");
        }
       }).start();

1.  在java8之后：

new Thread(() -> System.out.println("Use lambda")).start();

可以看到，java8中利用lambda表达式大大简化了代码编写。  
此处简要提下，用lambda表达式代替匿名类的关键在于，匿名类实现的接口使用了java.lang.FunctionalInterface注解，且只有一个待实现的抽象接口方法，如Runnable接口：

@FunctionalInterface
      public interface Runnable {
        
          public abstract void run();
      }

本文后面会详细讲解FunctionalInterface注解。

3.2 java List迭代的lambda实现  
开发同学经常会使用到集合类，并对集合类对象进行迭代，以实现业务逻辑。  
java8中，集合类的顶层接口java.lang.Iterable定义了一个forEach方法：

/* @param action The action to be performed for each element
         * @throws NullPointerException if the specified action is null
         * @since 1.8
         */
        default void forEach(Consumer<? super T> action) {
        
            Objects.requireNonNull(action);
            for (T t : this) {
        
                action.accept(t);
            }
        }

forEach方法可以迭代集合的所有对象，其参数为Consumer对象，Consumer类位于java.util.function包下，我们看下其定义：

@FunctionalInterface
    public interface Consumer<T> {
        
        void accept(T t);
    
        default Consumer<T> andThen(Consumer<? super T> after) {
        
            Objects.requireNonNull(after);
            return (T t) -> {
         accept(t); after.accept(t); };
        }
    }

到此已经很容易联想到，我们可以采用lambda表达式来实现java8集合的迭代逻辑，下面我们进行示例：

1.  在java8之前：

List<Integer> features = Arrays.asList(1,2);
        for (Integer feature : features) {
        
             System.out.println(feature);
         }

1.  在java8之后：

List<Integer> features = Arrays.asList(1,2);
        features.forEach(n -> System.out.println(n));

上述逻辑还可以用java8的方法引用来表示：

List<Integer> features = Arrays.asList(1,2);
        features.forEach(System.out::println);

方法引用也是java8的新特性，由::操作符标示，详细可参考方法引用的文章，本文不赘述。

## 四、函数式接口 ##

在上一节中我们提到：“用lambda表达式代替匿名类的关键在于，匿名类实现的接口使用了java.lang.FunctionalInterface注解，且只有一个待实现的抽象接口方法”, 这里的接口便是函数式接口。  
函数式接口(Functional Interface)是java8新增的特性，它是一个**有且仅有一个抽象方法，但是可以有多个非抽象方法的接口**。函数式接口可以被隐式转换为lambda表达式。  
Runnable接口是在JDK1.8之前已经存在的接口，在JDK1.8中加入了@FunctionalInterface注解，表示将其定义为一个函数式接口。在JDK1.8中定义的函数式接口还有：

*  java.util.concurrent.Callable
 *  java.security.PrivilegedAction
 *  java.util.Comparator
 *  java.io.FileFilter
 *  java.nio.file.PathMatcher
 *  java.lang.reflect.InvocationHandler
 *  java.beans.PropertyChangeListener
 *  java.awt.event.ActionListener
 *  javax.swing.event.ChangeListener

JDK1.8新增加的函数式接口有java.util.function包下的接口，典型的如上一节中提到的Consumer接口，感兴趣的读者可以阅读JDK1.8的源码，在此不逐个列出，在下一节本文还会列举java.util.function包中典型的函数式接口的使用。

**到这里，可以总结出，java8中用lambda表达式代替匿名内部类，本质上是将接口定义为函数式接口，并将函数式接口隐式转换为lambda表达式、**

## 五、典型函数式接口的使用 ##

上一节我们理解了java8函数式接口的概念和定义方法，本节再列举java.util.function几个典型的函数式接口的使用，加深下函数式接口与lambda表达式结合的理解。

#### 5.1 Predicate接口 ####

###### 5.1.1 Predicate接口的基本用法 ######

Predicate接口适合用于过滤，测试对象是否符合某个条件，Predicate接口源码如下：

@FunctionalInterface
    public interface Predicate<T> {
        
    
        boolean test(T t);
        
        default Predicate<T> and(Predicate<? super T> other) {
        
            Objects.requireNonNull(other);
            return (t) -> test(t) && other.test(t);
        }
       
        default Predicate<T> negate() {
        
            return (t) -> !test(t);
        }
    
        default Predicate<T> or(Predicate<? super T> other) {
        
            Objects.requireNonNull(other);
            return (t) -> test(t) || other.test(t);
        }
      
        static <T> Predicate<T> isEqual(Object targetRef) {
        
            return (null == targetRef)
                    ? Objects::isNull
                    : object -> targetRef.equals(object);
        }
    }

可以看到，Predicate接口待实现的唯一抽象方法是 boolean test(T t) 方法。我们用Predicate接口实现从整数型数组中过滤正数：

public static void main(String[] args)
        {
          
            List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
            filter(numbers, n -> n > 0);
        }
        
        public static void filter(List<Integer> numbers, Predicate<Integer> condition)
        {
        
            for (Integer number : numbers)
            {
        
                if (condition.test(number))
                {
        
                    System.out.println("Eligible number: " + number);
                }
            }
        }

运行结果如下：

Eligible number: 4
    Eligible number: 5

对数组的迭代，还可以使用Stream API的方式：

public static void main(String[] args)
        {
        
            List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
            numbers.stream().filter(n -> n > 0).forEach(n -> System.out.println("Eligible number: " + n));
        }

上面的代码采用**Stream API + Predicate接口 + Consumer接口**的方式实现了同样的功能，代码量大大减少。**Stream API（java.util.stream）同样是java8的新特性，将真正的函数式编程风格引入到java语言中**，进一步简化了代码。

###### 5.1.2 Predicate接口的进阶用法 ######

我们再看上一节提到的Predicate接口的源码，发现它有三个default关键字定义的方法，分别为and()、negate()、or()三个方法，顾名思义，它们类似于逻辑操作&&、!、||，用于生成新的Predicate对象。

以上一节的数组为例，我们用and操作过滤出数组中大于-1且小于5的数字：

public static void main(String[] args)
        {
          
            List<Integer> numbers = Arrays.asList(-1, -2, 0, 4, 5);
            filter(numbers, n -> n > -1 , n -> n < 5);
        }
        
        public static void filter(List<Integer> numbers, Predicate<Integer> first, Predicate<Integer> second)
        {
        
            for (Integer number : numbers)
            {
        
                if (first.and(second).test(number))
                {
        
                    System.out.println("Eligible number: " + number);
                }
            }
        }

结果为：

Eligible number: 0
    Eligible number: 4

上例用and()方法将两个Predicate对象进行and运算，同理negate()、or()方法的使用也很简单，在此不再赘述。

#### 5.2 Stream API ####

Stream API将处理的数据源看做一种Stream（流），Stream（流）在Pipeline（管道）中传输和运算，Stream API结合lambda表达式可以很方便的对集合进行筛选、排序等运算，由于篇幅较大，请阅读【java8新特性】Stream API详解，本文中不详细讲解。

#### 5.3 Optional ####

Optional类是Java8为了解决null值判断问题，借鉴google guava类库的Optional类而引入的一个同名Optional类，使用Optional类配合lambda表达式可以避免显式的null值判断，并实现很多类似Stream API的功能，由于篇幅较大，请阅读【java8新特性】Optional详解，本文中不详细讲解。

## 五、注意事项 ##

1.  lambda表达式可以使用方法引用，当且仅当主体中不修改lambda表达式提供的参数，如第三章提到的两种写法

features.forEach(n -> System.out.println(n));
    等价于
    features.forEach(System.out::println);

而如果对参数有任何修改时不能使用方法引用，如：

features.forEach(n -> System.out.println(n+1));

1.  lambda与匿名类的联系和区别  
    联系：  
    　1） 都可以访问final或effectively final局部变量。  
    　2） 生成的对象都可以调用实现的接口方法。  
    区别：  
    　1） this指针的指向不同。我们知道匿名类的this指针指向匿名类，而lambda表达式的this指针指向的是包围lambda表达式的类。  
    　2） 编译方式不同。lambda在编译器内部被翻译为私有方法，并使用了Java 7的 invokedynamic 字节码指令来动态绑定这个方法  
    　3） 实现的接口限制有区别。匿名类可以为任意接口创建实例，只要实现接口所有的抽象方法即可；而lambda表达式只能实现函数式接口（只有一个必须实现的抽象方法）。  
    　4） 接口默认方法的调用权限不同。匿名类实现的抽象方法允许调用接口中的默认方法，而lambda表达式不能调用接口中的默认方法。

--------------------

*  [【java8新特性】——lambda表达式与函数式接口详解（一）][java8_lambda]
 *  [【java8新特性】——Stream API详解（二）][java8_Stream API]
 *  [【java8新特性】——Optional详解（三）][java8_Optional]
 *  [【java8新特性】——方法引用（四）][java8]
 *  [【java8新特性】——默认方法（五）][java8 1]

[java8_lambda]: https://blog.csdn.net/qq_43842093/article/details/120679357
[java8_Stream API]: https://blog.csdn.net/qq_43842093/article/details/120679615
[java8_Optional]: https://blog.csdn.net/qq_43842093/article/details/120679801
[java8]: https://blog.csdn.net/qq_43842093/article/details/120680281
[java8 1]: https://blog.csdn.net/qq_43842093/article/details/120680985