【Java基础】Java Lambda表达式详解

浅浅的花香味﹌ 2023-09-30 19:54 57阅读 0赞

**Lambda** 表达式，即函数式编程是 JDK8 的一个新特性，也被称为闭包，Lambda表达式允许把函数作为一个方法的参数，即行为参数化，函数作为参数传递进方法中。

Lambda表达式可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

**总结就是：使用不可变值与函数，函数对不可变值进行处理，映射成另一个值。**

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

### **一、什么是函数式接口** ###

函数接口是只有一个抽象方法的接口，用作 Lambda 表达式的类型。使用@FunctionalInterface注解修饰的类，编译器会检测该类是否只有一个抽象方法或接口，否则，会报错。可以有多个默认方法，静态方法。

lambda 表达式是一小段代码，它接受参数并返回一个值。Lambda 表达式类似于方法，但它们不需要名称，并且可以直接在方法体中实现。

**语法：**最简单的 lambda 表达式包含一个参数和一个表达式：

*  **零参数：**

() -> System.out.println("零参数 lambda");

*  **一个参数：**

p -> System.out.println("一个参数：" + param);

*  **多个参数：**

(p1 [,p2,p3,....pn]) -> System.out.println("多个参数：" + p1 + ", " + p2 + ... + pn);

上面的表达式有一定的限制。它们要么返回一个值要么执行一段方法，并且它们不能包含变量、赋值或语句，例如**if** or **for** 。为了进行更复杂的操作，可以使用带有花括号的代码块。如果 lambda 表达式**需要返回一个值**，那么代码块应该有一个**return**语句。

(parameter1, parameter2) -> { code block [return] }

#### 1、方法引用 ####

*  **类 :: 静态方法**

Consumer<String> c = [ (s) -> System.out.println(s);  <=>  System.out::println; ]

*  **对象 :: 实例方法**

List<String> list = Lists.newArrayList();
    Consumer<String> c = [ (e) => list.add(e);  <=>  list::add; ]

*  **构造器 :: new**

Supplier<List<String>> s = [ () -> new ArrayList<>(); <=> ArrayList::new; ]

#### **2、@FunctionalInterface注解** ####

有且只有一个抽象方法的接口被称为函数式接口，函数式接口适用于函数式编程的场景，Lambda就是Java中函数式编程的体现，可以使用Lambda表达式创建一个函数式接口的对象，一定要确保接口中有且只有一个抽象方法，这样Lambda才能顺利的进行推导。

与@Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解：@FunctionalInterface 。该注解可用于一个接口的定义上,一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实**有且仅有一个抽象方法（equal和hashcode方法不算**），否则将会报错。但是这个注解不是必须的，只要符合函数式接口的定义，那么这个接口就是函数式接口。

#### **3、 java8自带的常用函数式接口。** ####

![346085955c143a1ecda749135d9426dc.png][]

#### 4、简单的例子 ####

package com.biyu.study.lambda;
    
    import com.biyu.study.lambda.bean.Employee;
    
    import java.math.BigDecimal;
    import java.util.function.*;
    
    public class Test {
        public static void main(String[] args) {
            Predicate<Integer> predicate = x -> x > 20;
            Employee employee = new Employee("Lily", "女", 18);
            System.out.println("Lily的大于18岁吗？：" + predicate.test(employee.getAge()));
    
            Consumer<String> consumer = System.out::println;
            consumer.accept("Hello World");
    
            Function<Employee, String> function = Employee::getName;
            String name = function.apply(employee);
            System.out.println(name);
    
            Supplier<Integer> supplier = () -> Integer.valueOf(BigDecimal.TEN.toString());
            System.out.println(supplier.get());
    
            UnaryOperator<Boolean> unaryOperator = uglily -> !uglily;
            Boolean apply2 = unaryOperator.apply(true);
            System.out.println(apply2);
    
            BinaryOperator<Integer> operator = (x, y) -> x * y;
            Integer integer = operator.apply(2, 3);
            System.out.println(integer);
    
            test(() -> "函数式接口");
        }
    
        /**
         * 自定义函数式接口使用
         *
         * @param worker
         */
        public static void test(Worker worker) {
            String work = worker.work();
            System.out.println(work);
        }
    
        public interface Worker {
            String work();
        }
    }

![d56a4d7a6e23753653a65490803a50d0.png][]

以上演示了lambda接口的使用及自定义一个函数式接口并使用。

### 二、Lambda 流的常用方法 ###

#### **1、ForEach** ####

集合的遍历 forEach 方法：

public static void testForEach(){
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("3");
            }};
    
            list.forEach(s-> System.out.println(s));
        }

![6d7f6375fc5ffa51589294be2d8e22ab.png][]

#### **2、Collect** ####

将操作后的对象转化为新的对象：

public static void testCollect(){
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("2");
            }};
    
            //转换为新的list
            List newList = list.stream().map(s -> Integer.valueOf(s)).collect(Collectors.toList());
            System.out.println(newList);
        }

#### **3、Filter** ####

Filter 为过滤的意思，只要满足 Filter 表达式的数据就可以留下来，不满足的数据被过滤掉。

public static void testFilter() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("3");
            }};
    
            List<String> filtered = list.stream()
                    // 过滤掉我们希望留下来的值
                    // 表示我们希望字符串是 1 能留下来
                    // 其他的过滤掉
                    .filter(str -> "1".equals(str))
                    .collect(Collectors.toList());
            System.out.println(filtered);
        }

![d782afdd17d9eb505b3df58e089e9446.png][]

#### **4、Map** ####

map 方法可以让我们进行一些流的转化，比如原来流中的元素是 A，通过 map 操作，可以使返回的流中的元素是 B。

public static void testMap() {
            List<String> list = new ArrayList<String>() {
        {
                add("A");
                add("B");
                add("C");
            }};
            //通过 map 方法list中元素转化成 小写
            List<String> strLowerList = list.stream()
                    .map(str -> str.toLowerCase())
                    .collect(Collectors.toList());
            System.out.println(strLowerList);
        }

![ff6026cc4280606cfb744f587ef18447.png][]

#### **5、MapToInt** ####

mapToInt 方法的功能和 map 方法一样，只不过 mapToInt 返回的结果已经没有泛型，已经明确是 int 类型的流了。

public static void testMapToInt() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("3");
            }};
            List<Integer> intList=list.stream()
                    .mapToInt(s->Integer.valueOf(s))
                    // 一定要有 mapToObj，因为 mapToInt 返回的是 IntStream，因为已经确定是 int 类型了，所以没有泛型的，
                    // 而 Collectors.toList() 强制要求有泛型的流，所以需要使用 mapToObj方法返回有泛型的流
                    .mapToObj(s->s)
                    .collect(Collectors.toList());
            System.out.println(intList);
            Double sum = list.stream()
                    .mapToDouble(s->Double.valueOf(s))
                    // DoubleStream/IntStream 有许多 sum（求和）、min（求最小值）、max（求最大值）、average（求平均值）等方法
                    .sum();
            System.out.println(sum);
        }

![d3c99099e510ae5d8bb17130c96e2199.png][]

#### **6、Distinct** ####

distinct 方法有去重的功能：

public static void testDistinct() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("2");
                add("5");
                add("3");
            }};
            List<Integer> intList = list.stream()
                    .map(s -> Integer.valueOf(s))
                    .distinct()
                    .collect(Collectors.toList());
            System.out.println(intList);
        }

![b3806fa8d7b79891df042b812540a765.png][]

#### **7、Sorted** ####

Sorted 方法提供了排序的功能，并且允许我们自定义排序。

public static void testSorted() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("-1");
                add("9");
                add("11");
                add("27");
                add("0");
            }};
            List<Integer> intList = list.stream()
                    .map(s -> Integer.valueOf(s))
                    // 等同于 .sorted(Comparator.naturalOrder()) 自然排序
                    .sorted()
                    .collect(Collectors.toList());
            System.out.println(intList);
            // 自定义排序器
            intList =list.stream()
                    .map(s -> Integer.valueOf(s))
                    // 反自然排序
                    .sorted(Comparator.reverseOrder())
                    .collect(Collectors.toList());
            System.out.println(intList);
        }

![af182eb5bb563c69d3bacf3e9834b675.png][]

#### **8、groupingBy** ####

groupingBy 是能够根据字段进行分组，toMap 是把 List 的数据格式转化成 Map 的格式。

public static void testGroupBy() {
            List<String> list = new ArrayList<String>() {
        {
                add("iphone 4s");
                add("iphone 6");
                add("iphone 12");
                add("iphone 14");
                add("xiaomi");
                add("huawei");
                add("oppo");
            }};
    
            Map<String, List<String>> strList = list.stream().collect(Collectors.groupingBy(s -> {
    
                if (s.startsWith("iphone")){
                    return "iphone";
                } else {
                    return "other";
                }
            }));
            System.out.println(strList);
        }

![efa6edc9e703f053873eedae9802763c.png][]

#### **9、FindFirst** ####

findFirst 表示匹配到第一个满足条件的值就返回：

public static void testFindFirst() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("2");
            }};
    
            list.stream()
                    .filter(s -> "2".equals(s))
                    .findFirst()
                    .get();
    
            // 防止空指针
            list.stream()
                    .filter(s -> "2".equals(s))
                    .findFirst()
                    // orElse 表示如果 findFirst 返回 null 的话，就返回 orElse 里的内容
                    .orElse("3");
    
            Optional<String> str = list.stream()
                    .filter(s -> "2".equals(s))
                    .findFirst();
            // isPresent 为 true 的话，表示 value != null
            if (str.isPresent()) {
                return;
            }
        }

#### **10、Reduce** ####

reduce 方法允许我们在循环里面叠加计算值：

public static void testReduce() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("3");
            }};
    
            int sum = list.stream()
                    .map(s -> Integer.valueOf(s))
                    // s1 和 s2 表示循环中的前后两个数
                    .reduce((s1, s2) -> s1 + s2)
                    .orElse(0);
            System.out.println(sum);
            sum =list.stream()
                    .map(s -> Integer.valueOf(s))
                    // 第一个参数表示基数，会从 100 开始加
                    .reduce(100, (s1, s2) -> s1 + s2);
            System.out.println(sum);
        }

![b3b31b6ded677b93f0646696bb8f8511.png][]

#### **11、Peek** ####

peek 方法很简单，我们在 peek 方法里面做任意没有返回值的事情，比如打印日志：

public static void testPeek() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("3");
            }};
            list.stream().map(s -> Integer.valueOf(s))
                    .peek(s -> System.out.println(s))
                    .collect(Collectors.toList());
        }

![4b08c98753cf75e14edefdbf7109c001.png][]

#### **12、Limit** ####

limit 方法会限制输出值个数，入参是限制的个数大小：

public static void testLimit() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("2");
                add("3");
                add("4");
                add("5");
            }};
           List<Integer> integers= list.stream()
                    .map(s -> Integer.valueOf(s))
                    .limit(3L)
                    .collect(Collectors.toList());
            System.out.println(integers);
    
        }

![f0741df66932fec4f135d87e1a6737a4.png][]

#### **13、Max，Min** ####

通过 max、min 方法，可以获取集合中最大、最小的对象。

public static void testMaxMin() {
            List<String> list = new ArrayList<String>() {
        {
                add("1");
                add("3");
                add("2");
                add("-12");
                add("99");
            }};
    
            String maxNum = list.stream().max(Comparator.comparing(s -> Integer.valueOf(s))).get();
            String minNum = list.stream().min(Comparator.comparing(s -> Integer.valueOf(s))).get();
            System.out.println(maxNum);
            System.out.println(minNum);
        }

![8266244b7c5cff77ab9d8e632b252ca2.png][]

### **三、写在最后** ###

本章节主要从实际使用讲述了常用的方法及流，文中例子主要是为了讲解较为简单，大家可以去使用java8重构自己现有的代码，自行领会lambda的奥妙使用。java8可以很清晰表达你要做什么，代码也很简洁。

[346085955c143a1ecda749135d9426dc.png]: https://img-blog.csdnimg.cn/img_convert/346085955c143a1ecda749135d9426dc.png
[d56a4d7a6e23753653a65490803a50d0.png]: https://img-blog.csdnimg.cn/img_convert/d56a4d7a6e23753653a65490803a50d0.png
[6d7f6375fc5ffa51589294be2d8e22ab.png]: https://img-blog.csdnimg.cn/img_convert/6d7f6375fc5ffa51589294be2d8e22ab.png
[d782afdd17d9eb505b3df58e089e9446.png]: https://img-blog.csdnimg.cn/img_convert/d782afdd17d9eb505b3df58e089e9446.png
[ff6026cc4280606cfb744f587ef18447.png]: https://img-blog.csdnimg.cn/img_convert/ff6026cc4280606cfb744f587ef18447.png
[d3c99099e510ae5d8bb17130c96e2199.png]: https://img-blog.csdnimg.cn/img_convert/d3c99099e510ae5d8bb17130c96e2199.png
[b3806fa8d7b79891df042b812540a765.png]: https://img-blog.csdnimg.cn/img_convert/b3806fa8d7b79891df042b812540a765.png
[af182eb5bb563c69d3bacf3e9834b675.png]: https://img-blog.csdnimg.cn/img_convert/af182eb5bb563c69d3bacf3e9834b675.png
[efa6edc9e703f053873eedae9802763c.png]: https://img-blog.csdnimg.cn/img_convert/efa6edc9e703f053873eedae9802763c.png
[b3b31b6ded677b93f0646696bb8f8511.png]: https://img-blog.csdnimg.cn/img_convert/b3b31b6ded677b93f0646696bb8f8511.png
[4b08c98753cf75e14edefdbf7109c001.png]: https://img-blog.csdnimg.cn/img_convert/4b08c98753cf75e14edefdbf7109c001.png
[f0741df66932fec4f135d87e1a6737a4.png]: https://img-blog.csdnimg.cn/img_convert/f0741df66932fec4f135d87e1a6737a4.png
[8266244b7c5cff77ab9d8e632b252ca2.png]: https://img-blog.csdnimg.cn/img_convert/8266244b7c5cff77ab9d8e632b252ca2.png