【java基础】一篇文章彻底搞懂lambda表达式

lambda表达式是什么

lambad表达式是一个可传递的代码块，可以在以后执行一次或者多次。

我们都知道java是面向对象的语言，我们在进行方法传递时，并不能直接传递代码段，而是要传递一个对象，这个对象中有一个方法包含了想要传递的代码段。

例如Arrays.sort就要一个Comparator接口，我们就只能传递一个实现该接口的对象。

        Integer[] nums = {
    
    4, 1, 3, 2};
        Arrays.sort(nums, new Comparator<Integer>() {
    
    
            @Override
            public int compare(Integer o1, Integer o2) {
    
    
                return o2 - o1;
            }
        });

在其他一些语言中，可以直接处理代码块，但是java一直没有增加这个特性，因为java的强大之处就在于其简单性和一致性。好在在jdk8中加入了一种lambad的设计，我们可以使用lambda就可以实现类似代码块传递的功能，极大的简化了代码。
我们上面的代码使用lambad就可以改写为如下形式

        Integer[] nums = {
    
    4, 1, 3, 2};
        Arrays.sort(nums, (o1, o2) -> o2 - o1);

lambda表达式的语法

这里我先简单说明一下，lambda表达式其实就是用来实现某个抽象方法的，并且某个抽象类或者接口只有一个抽象方法才能使用lambda表达式。下面的例子也是基于String类型的Comparator中的compare抽象方法

lambda的语法就是 (参数) -> {代码逻辑}
我们利用lambda来实现方法，一个简单的例子如下

		(String s1, String s2) -> {
    
    
            return s1.length() - s2.length();
        };

如果代码块里面只有一行语句，那么就可以省略大括号，直接写在一行

(String s1, String s2) -> s1.length() - s2.length();

写在一行就可以省略return关键字了
关于lambda并不是一定要有返回值，是否要有返回值是却决于要实现的抽象方法是否有返回值的。

对于一个lambda方法，在很多情况下都是可以省略参数上面的类型的，因为编译器可以推断出

(s1, s2) -> s1.length() - s2.length();

对于只有一个参数的lambda，我们可以省略参数的括号。对于没有参数的lambda我们又必须要写上该括号

s -> s.length();

() -> System.out.println(1);

这里介绍了lambda的一些形式，看不懂不要紧，下面就开始具体说明。

函数式接口

对于只有一个抽象方法的接口，需要这种接口的对象时，我们就可以提供一个lambda表达式。这种接口就称为函数式接口。

初次使用

我们还是来看一下Arrays.sort方法

该sort方法就需要提供一个实现Comparator的接口。下面再来看一下Comparator接口

这个接口有很多方法，但是只有compare是抽象方法，其他都有默认实现，所以这个就符合函数式接口的定义，我们使用Arrays.sort方法时，就不需要传入一个实现Comparator的对象，只需要传入一个lambda的表达式就行了。

下面就是使用lambda就行排序的例子

public class People {
    
    
    private String name;
    private Integer age;

    public People(String name, Integer age) {
    
    
        this.name = name;
        this.age = age;
    }

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public Integer getAge() {
    
    
        return age;
    }

    public void setAge(Integer age) {
    
    
        this.age = age;
    }

    @Override
    public String toString() {
    
    
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

我们有一个People对象数组，现在要求对这个数组进行排序，排序要求为按照名称的长度排序，升序

        People[] people = {
    
    
                new People("cc", 19),
                new People("ttpfx", 21),
                new People("tom", 26),
                new People("lucy", 20)
        };

我们要使用lambda表达式，首先要搞清楚用lambda所对应的抽象方法，我们这里要实现的方法就是compare方法，传入2个参数，返回一个int

这里的T就是一个泛型，由于我们是对People排序，所以T就是代表People对象。知道了这些，我们就可以写lambda表达式了。

Arrays.sort(people, (p1, p2) -> p1.getName().length() - p2.getName().length());

上面的代码就可以实现People数组按照名称长度升序排列

对应lambda表达式，我们最好将其看作是一个函数，而不是一个对象。

深入理解

对于上面lambda表达式，我们还可以简写，形式如下

Arrays.sort(people, Comparator.comparingInt(p -> p.getName().length()));

对于上面的表达式，我来进行说明一下，由于Arrays.sort需要一个Comparator，所以我们需要提供一个Comparator，但是Comparator.comparingInt会返回一个Comparator。所以没问题

又由于comparingInt需要接受一个ToIntFunction，我们再来看一下ToIntFunction

可以发现ToIntFunction就只有一个抽象方法，所以我们又可以使用lambda表达式，最终的形式就是下面那样的。

Arrays.sort(people, Comparator.comparingInt(p -> p.getName().length()));

对于泛型，默认大家都是很了解的，这篇文章不会进行讲解，如果感觉有点看不懂了，请先去学习泛型

方法引用 :: 用法

快速入门

有的时候，如果我们lambda涉及到一个方法，例如我们创建了一个定时器，要求每秒打印一下这个事件对象，代码如下

Timer timer = new Timer(1000, event -> System.out.println(event));

这里为什么可以使用lambda表达式，大家应该都可以猜出来了，原因就是Timer的第二个参数是应该函数式接口，只有一个抽象方法，Timer的第二个参数内容如下。

对于上面的写法我们可以简写为如下形式

Timer timer = new Timer(1000, System.out::println);

对于 System.out::println 这个写法可能已经很多人蒙了，这是啥东西啊。其实 System.out::println 就是一个方法引用，就代表引用System.out对象的println方法。System.out::println指示编译器生成一个函数式接口的实例，覆盖这个接口的抽象方法来调用给定的方法。相信大家看完还是很蒙，下面就再通俗的解释一下。

• 我们通过ActionListener源代码可以发现actionPerformed会传入一个 ActionEvent对象 e，返回值为void，也就是没有返回值。
• 我们再来看一下System.out的println的方法
  
  可以发现println接受一个Object的参数，返回值也是void
• 我们将 actionPerformed 和 println 进行对比，是不是发现很相似呢？对于actionPerformed 的参数，我们也可以通过Object来进行接收。
• 我们再lambda表达式里面编写的逻辑就是打印参数，println的任务就是打印，既然如此，那为什么我们不直接将println这个方法用来覆盖actionPerformed 掉方法呢？
• 事实上System.out::println，我们就是用println方法覆盖掉了actionPerformed 方法，我们调用actionPerformed(e)时，实际上就是调用println(e)方法了。

对于上面的说明，仅仅为个人的理解。如果有误还请在评论区指出。

如果要使用 :: 形式的lambda表达式，必须返回值相同，参数个数相同，参数类型相同或者为父类

不同形式的::

对于使用::分隔方法名与对象名或类名，主要有以下3种情况

• object::instanceMethod
• Class::instanceMethod
• Class::staticMethod

情况1 object::instanceMethod

在第一种情况下，方法引用等价于向方法传递参数的lambda的表达式。例如上面的System.out::printl1n就等价于 x -> System.out.println(x)

情况2 Class::instanceMethod

对于这种情况，我先举一个例子，现在有一个要求就是对String数组按照字母升序排列，忽略大小写

        String[] names = {
    
    "Tom", "CC", "tTpfx", "JURY"};

对于上面的要求，经过上面要求，我们该怎么完成呢？通过上面的lambda的学习，我们可以通过lambda表达式完成，我们调用compareToIgnoreCase这个方法进行比较就行了

        Arrays.sort(names, (name1, name2) -> name1.compareToIgnoreCase(name2));

我们来看一下compareToIgnoreCase的源代码

可以发现这个和我们要传入Comparator的compare方法参数和返回类型都是一样，这样那我们岂不是就可以使用::的写法了。也确实是这样的。::写法如下

        Arrays.sort(names, String::compareToIgnoreCase);

可以发现十分的简洁。

经过上面的例子，现在就可以对上面的 Class::instanceMethod 进行说明了，Class就代表类名，instanceMethod 就代表实例方法。对于这种情况，第一个参数就会成为隐式参数。也就是说String::compareToIgnoreCase 相当于 (name1, name2) -> name1.compareToIgnoreCase(name2)

情况3 Class::staticMethod

这种情况就不举例了，理解了情况2现在来理解这个很简单。Class::staticMethod就相当于将所有参数传递到参数列表，例如 Math::pow 就等价于 (a,b) -> Math.pow(a,b)

对于 :: 的一些示例及其注意事项

下图就是::的一些示例

对于::的注意事项如下

• 只有当lambda表达式的体只调用一个方法并且不做其他操作时，才可以把lambda表达式重写为方法引用
• 如果要引用的方法具有多个重载的方法，编译器会找出最相似的方法
• 方法引用不能单独存在，总是会转换为函数式接口的实例
• 包含对象的方法引用与等价的lambda表达式还有一个细微的差别。考虑一个方法法引用，如separator::equals.。如果separator为null,构造separator::equals时就会立抛出一个异常。lambda表达式x -> separator.equals(x)只在调用时才会拋出NullPointerException。
• 对于::我们可以使用this和super，this代表当前类，super表示父类

构造器引用

构造器引用和方法引用很类似，只不过将方法名换成了new，下面就是应该例子

public class Cat {
    
    
    public Cat() {
    
    
    }

    public Cat(Cat cat) {
    
    
    }
}

下面代码将一个集合转换为数组

    @Test
    public void t4() {
    
    
        List<Cat> list = new ArrayList<>();
        list.add(new Cat());
        list.add(new Cat());
        Stream<Cat> stream = list.stream().map(Cat::new);
        Cat[] cats = stream.toArray(Cat[]::new);
        System.out.println(Arrays.toString(cats));
    }

里面的第一个Cat::new 就代表引用构造器。相当于 c -> new Cat©
第二个Cat[]::new 相当于 x -> new Cat[x]

变量作用域

使用外部变量

在lambda表达式中，我们使用的外部变量必须是最终变量或实际上的最终变量。
例如下面代码是没有问题的

    @Test
    public void t1() {
    
    
        int i = 1;
        Integer[] nums = {
    
    2, 1, 3};
        Arrays.sort(nums, (n1, n2) -> {
    
    
            System.out.println(i);
            return n2 - n1;
        });
        System.out.println(Arrays.toString(nums));
    }

我们在lambda里面打印i的值，没有任何问题。但是我们如果将i的值改变

    @Test
    public void t1() {
    
    
        int i = 1;
        Integer[] nums = {
    
    2, 1, 3};
        i++;
        Arrays.sort(nums, (n1, n2) -> {
    
    
            System.out.println(i);
            return n2 - n1;
        });
        System.out.println(Arrays.toString(nums));
    }

此时再运行，编译器就会输出如下信息

IDEA也会给出以下提示，告诉我们变量的值是不能够改变的

定义内部变量

对于lambda表达式，我们再里面还不能够定义与外部变量相同的参数名称，例如下面代码

    @Test
    public void t1() {
    
    
        int i = 1;
        Integer[] nums = {
    
    2, 1, 3};
        Arrays.sort(nums, (n1, n2) -> {
    
    
            int i = 0;
            return n2 - n1;
        });
        System.out.println(Arrays.toString(nums));
    }

我们再lambda里面定义了与外部变量同名的i变量，这时候IDEA就会给出以下提示

如果运行就会报错

this指向问题

在lambda里面的this就是创建lambda那个方法的this。

    @Test
    public void t2() {
    
    
        Integer[] nums = {
    
    2, 1};
        System.out.println(this.getClass().hashCode());
        Arrays.sort(nums, (n1, n2) -> {
    
    
            System.out.println(this.getClass().hashCode());
            return n2 - n1;
        });
    }

上面代码输出如下

也就代表这两个this是一样的。

lambda的好处

我们使用lambda的重点就是延迟执行，lambda只有在调用时才会执行。对于为什么需要延迟执行，参考下面的几点

• 在一个单独的线程中运行代码
• 多次运行代码
• 在算法的适当位置运行代码（例如，排序中的比较操作）
• 发生某种情况时执行代码（如，点击了一个按钮，数据到达，等等）
• 只在必要时才运行代码

常见的函数式接口

我们如果也想要编写支持lambda表达式的方法，我们就可以使用函数式接口来完成，不需要自己再去定义接口，下面就会列出一些常见的函数式接口

下图列出了基本类型int、long和double的34个可用的特殊化接口。使用这些特殊化接口比使用通用接口更高效。这些后面的博客中会进行说明

自己设计一个支持lambda的方法

我们就使用上面提供的一些函数式接口来设计一个支持lambda的方法
这个方法就使用到了Predicate这个函数式接口，对于这个接口忘了请参考如下

该接口源代码为

我们设计的方法如下

public class DesignLambdaMethod {
    
    

    public static <T> List<T> filterList(List<T> list, Predicate<T> predicate) {
    
    
        List<T> tList = new ArrayList<>();
        for (T t : list) {
    
    
            if (predicate.test(t)) {
    
    
                tList.add(t);
            }
        }
        return tList;
    }
}

这个方法接收一个List，然后接收一个Predicate，如果Predicate中的test方法返回为真，那么我们就不进行处理，否则就将其移除List。这个方法就可以用于过滤List。
具体使用如下

    public static void main(String[] args) {
    
    
        List<String> list = Arrays.asList("tom", "jack", "ttpfx", "mike", "lc");
        System.out.println(list);
        // 要求过滤掉list中的长度小于等于3的字符串
        List<String> newList = filterList(list, s -> s.length() > 3);
        System.out.println(newList);
    }

上面的程序运行后输出如下，成功完成需求

自定义函数式接口

对于函数式接口的定义想必大家已经很清楚了，只需要在接口有且只有抽象方法就是一个函数式接口。下面就是自定义的一个函数式接口

public interface MyInterface {
    
    

     <R> void apply(R r);
}

对于函数式接口，我们可以使用@FunctionalInterface进行标识。这样做有2个优点，如下

• 如果你无意中增加了另一个抽象方法，编译器会产生一个错误消息
• javadoc页里会指出你的接口是一个函数式接口。

@FunctionalInterface
public interface MyInterface {
    
    

     <R> void apply(R r);
}

如果使用@FunctionalInterface后，我们再增加一个抽象方法，那么就会出现以下错误信息

最后需要说明的是并不是一定要@FunctionalInterface接口，但是建议所有的函数式接口都使用该接口进行标识

总结

相信大家经过上面的讲解，对于lambda应该已经有了些大概的了解。这篇文章是根据我自己对lambda的理解写出的，如果讲解中有错误的地方还请评论区指出，共同提高