Java_lambda表达式详解

拼搏现实的明天。 2022-11-28 10:50 115阅读 0赞

### 文章目录 ###

*  使用要求
 *  函数式接口
 *  基础语法
 *   *  多参数无返回
     *  一个参数无返回
     *  无参数无返回
     *  多参数有返回
     *  一个参数有返回
     *  无参数有返回
 *  常用
 *   *  引用方法
     *  构造方法引用
     *  创建线程
     *  遍历集合
     *  删除集合中元素
     *  集合中元素排序
 *  闭包问题

> 转自https://www.cnblogs.com/haixiang/p/11029639.html

# 使用要求 #

接口中只能有一个需要被实现的方法，default方法有默认实现。

# 函数式接口 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70_pic_center]

# 基础语法 #

## 多参数无返回 ##

/**多参数无返回*/
    @FunctionalInterface
    public interface NoReturnMultiParam {
        
        void method(int a, int b);
    }
    
    //多个参数无返回
    NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
        
         System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
     };
     noReturnMultiParam.method(6, 8);
    
    // 简化
    // 简化参数类型，可以不写参数类型，但是必须所有参数都不写
    // 简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
    NoReturnMultiParam noReturnMultiParam = (a, b) -> System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
    noReturnMultiParam.method(6, 8);

## 一个参数无返回 ##

/**一个参数无返回*/
    @FunctionalInterface
    public interface NoReturnOneParam {
        
        void method(int a);
    }
    
    //一个参数无返回
    NoReturnOneParam noReturnOneParam = (int a) -> {
        
        System.out.println("NoReturnOneParam param:" + a);
    };
    noReturnOneParam.method(6);
    
    // 简化
    // 简化参数类型，可以不写参数类型，但是必须所有参数都不写
    // 简化参数小括号，如果只有一个参数则可以省略参数小括号
    // 简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
    NoReturnOneParam noReturnOneParam = a -> System.out.println("NoReturnOneParam param:" + a);

## 无参数无返回 ##

/**无参无返回值*/
    @FunctionalInterface
    public interface NoReturnNoParam {
        
        void method();
    }
    
    //无参无返回
    NoReturnNoParam noReturnNoParam = () -> {
        
        System.out.println("NoReturnNoParam");
    };
    noReturnNoParam.method();
    
    // 简化
    //简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
    NoReturnNoParam noReturnNoParam = () -> System.out.println("NoReturnNoParam");

## 多参数有返回 ##

/**多个参数有返回值*/
    @FunctionalInterface
    public interface ReturnMultiParam {
        
        int method(int a, int b);
    }
    
    //多个参数有返回值
     ReturnMultiParam returnMultiParam = (int a, int b) -> {
        
         return a+b;
     };
    
     int res3 = returnMultiParam.method(6, 8);
     System.out.println("return:" + res3);
     
     // 简化
     // 简化参数类型，可以不写参数类型，但是必须所有参数都不写
     // 简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
     // 如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号还入return关键字
      ReturnMultiParam returnMultiParam = (a, b) -> a+b;

## 一个参数有返回 ##

/**一个参数有返回值*/
    @FunctionalInterface
    public interface ReturnOneParam {
        
        int method(int a);
    }
    
    //一个参数有返回值
    ReturnOneParam returnOneParam = (int a) -> {
        
        return a;
    };
    
    int res2 = returnOneParam.method(6);
    System.out.println("return:" + res2);
    
    // 简化
    // 简化参数类型，可以不写参数类型，但是必须所有参数都不写
    // 简化参数小括号，如果只有一个参数则可以省略参数小括号
    // 简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
     // 如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号还入return关键字
    ReturnOneParam returnOneParam = a -> a;

## 无参数有返回 ##

/*** 无参有返回*/
    @FunctionalInterface
    public interface ReturnNoParam {
        
        int method();
    }
    
    //无参有返回值
    ReturnNoParam returnNoParam = () -> {
        
        return 1;
    };
    
    int res = returnNoParam.method();
    System.out.println("return:" + res);
    
    // 简化
    // 简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
    // 如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号还入return关键字
    ReturnNoParam returnNoParam = () -> 1;

# 常用 #

## 引用方法 ##

不是必须要重写某个匿名内部类的方法，可以利用 lambda表达式的接口快速指向一个已经被实现的方法。

public class Exe1 {
        
    	/**
         * 要求
         * 1.参数数量和类型要与接口中定义的一致
         * 2.返回值类型要与接口中定义的一致
         * 语法：
         * 方法归属者::方法名 静态方法的归属者为类名，普通方法归属者为对象
         */
        public static int doubleNum(int a) {
        
            return a * 2;
        }
    
        public int addTwo(int a) {
        
            return a + 2;
        }
        
        public static void main(String[] args) {
        
            ReturnOneParam lambda1 = a -> doubleNum(a);
            System.out.println(lambda1.method(3));
    
            //lambda2 引用了已经实现的 doubleNum 方法
            ReturnOneParam lambda2 = Exe1::doubleNum;
            System.out.println(lambda2.method(3));
    
            Exe1 exe = new Exe1();
    
            //lambda4 引用了已经实现的 addTwo 方法
            ReturnOneParam lambda4 = exe::addTwo;
            System.out.println(lambda4.method(2));
        }    
    }

## 构造方法引用 ##

interface ItemCreatorBlankConstruct {
        
        Item getItem();
    }
    interface ItemCreatorParamContruct {
        
        Item getItem(int id, String name, double price);
    }
    
    public class Exe2 {
        
        public static void main(String[] args) {
        
            ItemCreatorBlankConstruct creator = () -> new Item();
            Item item = creator.getItem();
    
            ItemCreatorBlankConstruct creator2 = Item::new;
            Item item2 = creator2.getItem();
    
            ItemCreatorParamContruct creator3 = Item::new;
            Item item3 = creator3.getItem(112, "鼠标", 135.99);
        }
    }

## 创建线程 ##

new Thread(() -> {
        
      for (int i = 0; i < 10; i++) {
        
        System.out.println(i);
      }
    }).start();

## 遍历集合 ##

调用集合的 `public void forEach(Consumer<? super E> action)` 方法，通过 lambda 表达式的方式遍历集合中的元素。

ArrayList<Integer> list = new ArrayList<>();
    
    Collections.addAll(list, 1,2,3,4,5);
    
    //lambda表达式 方法引用
    list.forEach(System.out::println);
    
    list.forEach(element -> {
        
      if (element % 2 == 0) {
        
        System.out.println(element);
      }
    });

## 删除集合中元素 ##

通过`public boolean removeIf(Predicate<? super E> filter)`方法来删除集合中的某个元素

ArrayList<Item> items = new ArrayList<>();
    items.add(new Item(11, "小牙刷", 12.05 ));
    items.add(new Item(5, "日本马桶盖", 999.05 ));
    items.add(new Item(7, "格力空调", 888.88 ));
    items.add(new Item(17, "肥皂", 2.00 ));
    items.add(new Item(9, "冰箱", 4200.00 ));
    
    items.removeIf(ele -> ele.getId() == 7);
    
    //通过 foreach 遍历，查看是否已经删除
    items.forEach(System.out::println);

## 集合中元素排序 ##

ArrayList<Item> list = new ArrayList<>();
    list.add(new Item(13, "背心", 7.80));
    list.add(new Item(11, "半袖", 37.80));
    list.add(new Item(14, "风衣", 139.80));
    list.add(new Item(12, "秋裤", 55.33));
    
    /*
    list.sort(new Comparator<Item>() {
        @Override
        public int compare(Item o1, Item o2) {
            return o1.getId()  - o2.getId();
        }
    });
    */
    
    list.sort((o1, o2) -> o1.getId() - o2.getId());
    System.out.println(list);

# 闭包问题 #

类似于匿名内部类只能使用外部类的变量，而不能修改其值。

import java.util.function.Consumer;
    public class Main {
        
        public static void main(String[] args) {
        
    
            int num = 10;
    
            Consumer<String> consumer = ele -> {
        
                System.out.println(num);
            };
    
            //num = num + 2;
            consumer.accept("hello");
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/6bb9b78189ee47369a59e81eae31535b.png