Lambda

最新推荐文章于 2024-07-10 21:37:49 发布

敲代码的柯基Max

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量87

点赞数 2

分类专栏： Java 8 源码解读文章标签： java 开发语言程序人生 intellij-idea android studio

本文链接：https://blog.csdn.net/ERJI2022/article/details/132900401

版权

Java 8 源码解读专栏收录该内容

11 篇文章 1 订阅

订阅专栏

原文链接

文章目录

1、Lambda

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）
换句简单的话说： Lambda表达式允许你直接把一个代码块赋值给一个变量

2、语法

基本写法：(args1, args2, …)->{方法体}
语法小结
- 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
- 参数的小括号里面只有一个参数，那么小括号可以省略
- 如果方法体当中只有一句代码，那么大括号可以省略
- 如果方法体中只有一条语句，其是return语句，那么大括号可以省略，且去掉return关键字
无参数无返回值

public class Main {

    public static void main(String[] args) {

        // 接口的常规使用
        NoParameterNoReturn test = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("test");
            }
        };
        test.test();

        // lambda简化写法 只有一条语句，花括号可以省略
        NoParameterNoReturn test2 = () -> System.out.println("test2");
        test2.test();
    }

    public interface NoParameterNoReturn {
        void test();
    }
}

多参数无返回值

public class Main {

    public static void main(String[] args) {

        MoreParameterNoReturn moreParameterNoReturn = (r,t) -> {
            System.out.println(r);
            System.out.println(t);
            System.out.println(r+t);
        };
        moreParameterNoReturn.test(2,4);
    }

    public interface MoreParameterNoReturn {

        void test(int a,int b);
    }
}

有参有返回值

public class Main {

    public static void main(String[] args) {

        // 写法1：完整写法
        MoreParameterReturn moreParameterReturn = (int r,int t) -> {
            return r+t;
        };
        int test = moreParameterReturn.test(2, 4);
        System.out.println(test);


        // 写法2：省略参数类型
        MoreParameterReturn moreParameterReturn1 = (r,t) -> {
            return r+t;
        };
        int test1 = moreParameterReturn1.test(2, 4);
        System.out.println(test1);


        // 写法3：省略方法体 + reture
        MoreParameterReturn moreParameterReturn2 = (int r,int t) -> r+t;
        int test2 = moreParameterReturn2.test(2, 4);
        System.out.println(test2);
    }

    public interface MoreParameterReturn {

        int test(int a,int b);
    }
}

3、变量捕捉

3-1、实例1

简单写了一个匿名内部类，并且尝试捕获main函数中的变量a，下述代码正常执行

public class Main {

    public static void main(String[] args) {
        int a = 10;

        Test test = new Test() {
            @Override
            public void func() {
                System.out.println("我是内部类，并且重写func()");
                System.out.println("捕获变量："+a);
            }
        };
        test.func();
    }

    public static class Test {

        public void func(){
            System.out.println("func()");
        }
    }
}

3-2、实例2

发现这里报错了：从内部类引用的本地变量必须是最终变量或实际上的最终变量
在匿名内部类中，捕获外部的变量前提是——该变量没有发生修改，或该变量本身是个常量

public class Main {

    public static void main(String[] args) {
        int a = 10;
        
        a = 1;

        Test test = new Test() {
            @Override
            public void func() {
                System.out.println("我是内部类，并且重写func()");
                System.out.println("捕获变量："+a);
            }
        };
        test.func();
    }

    public static class Test {

        public void func(){
            System.out.println("func()");
        }
    }
}

3-3、解决方案

方案1：添加一个不修改的临时变量

public class Main {

    public static void main(String[] args) {

        int a = 10;
        a = 1;

        int finalA = a;
        Test test = new Test() {
            @Override
            public void func() {
                System.out.println("我是内部类，并且重写func()");
                System.out.println("捕获变量："+ finalA);
            }
        };
        test.func();
    }
}

方案2：将变量置为final

public class Main {

    public static void main(String[] args) {

        final int a = 10;

        Test test = new Test() {
            @Override
            public void func() {
                System.out.println("我是内部类，并且重写func()");
                System.out.println("捕获变量："+ a);
            }
        };
        test.func();
    }
}

4、双冒号

双冒号（::）运算符在Java 8中被用作方法引用（method reference），方法引用是与lambda表达式相关的一个重要特性。
它提供了一种执行方法的方法,为此，方法引用需要由兼容的函数式接口组成的目标类型上下文。
主要有以下几种用法
| 类型 | 引用语法 | 案例 |
| — | — | — |
| 引用静态方法 | 类名::静态方法名 | Integer::parseInt |
| 引用对象实例方法 | 对象::对象方法名 | System.out::println |
| 引用超类实例方法 | super::对象方法名 | |
| 引用类构造方法 | 类名::new | ArrayList::new |
| 引用数组构造方法 | 数组类型[]::new | String[]::new |
| 引用特定类型的任意对象的实例方法 | 需要满足特定的格式 | String::compareTo |

4-1、引用静态方法

方法引用对应一个函数式接口FunctionalInterface

        // 16进制的字符串”16“ 转换成十进制22
        BiFunction<String, Integer, Integer> parseInt = Integer::parseInt;
        Integer result = parseInt.apply("16", 16);
        System.out.println(result);// 22

常规用法

public class Main {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");

        // 写法1： lambda
        list.forEach((x) -> Main.print(x));

        // 写法2：双冒号
        list.forEach(Main::print);
    }

    //静态方法
    public static void print(String s) {
        System.out.println(s);
    }
}

4-2、引用对象实例方法

public class Main {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");

        // 写法1： lambda
        list.forEach((x) -> new Main().print(x));

        // 写法2：双冒号
        list.forEach(new Main()::print);
    }

    //静态方法
    public void print(String s) {
        System.out.println(s);
    }
}

4-3、引用超类实例方法

public class Main extends SuperMain {
    
    public void test(){
        List<String> list = Arrays.asList("a","b","c");
        //实例方法引用  instanceRef::methodName
        Consumer<String> print = super::print;
        list.forEach(print);
    }

    public static void main(String[] args) {

        new Main().test();
    }
}

public class SuperMain {
    public void print(String s){
        System.out.println(s);
    }
}

4-4、引用类构造方法

似懂非懂，待研究

public class Main {

    public static void main(String[] args) {
        // 无参构造方法引用
        PersonEmpty personEmpty = Person::new;
        Person person = personEmpty.createPerson();
        System.out.println(person);

        // 有参构造方法引用
        PersonNoEmpty personNoEmpty = Person::new;
        Person person2 = personNoEmpty.createPerson("zhangsan",12);
        System.out.println(person2);
    }
}

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

public interface PersonEmpty {
    Person createPerson();
}

public interface PersonNoEmpty {
    Person createPerson(String name, int age);
}

4-5、引用数组构造方法

似懂非懂，待研究

        Function<Integer,Person[]> function = Person[]::new;
        //调用apply方法创建数组，这里的5是数组的长度
        Person[] arr = function.apply(5);
        //循环输出-初始都为null
        for(Person c:arr){
            System.out.println(c);
        }

4-6、引用特定类的普通方法

似懂非懂，待研究
这里有个疑问compareTo不是静态方法，String::compareTo为何通过类名直接使用？？？

        String[] arr = { "Barbara", "James", "Mary", "John",
                "Patricia", "Robert", "Michael", "Linda" };
        Comparator<String> stringComparator = String::compareTo;
        Arrays.sort(arr, stringComparator);

        for(String s:arr){
            System.out.println(s);
        }

先看下这个写法

public class Main {

    public int compare(int param1, int param2) {
        int result = param1 - param2;
        System.out.println(result);
        return result;
    }

    public static void main(String[] args) {


        // 将一个具体方法赋值给MyInter
        MyInter a = Main::compare;

        a.test(new Main(), 2, 1);
    }

    interface MyInter {
        /**
         * main.involk(param1,param2)
         *
         * @param main   第一个参数 方法的调用者
         * @param param1 方法的入参
         * @param param2 方法的入参
         */
        void test(Main main, int param1, int param2);
    }

}

具体研究下发现这类方法有两个条件
- 第一点：interface中方法的参数比::方法的参数多一个
- 第二点：interface中方法的第一个参数恰巧是调用::方法的对象
再来看下之前的代码示例
- Arrays.sort需要一个Comparator接口方法，int compare(T o1, T o2);
- 第一个参数是方法的调用者，所以结果应该是o1.invoke(o2)，等效于
- (s1, s2) -> s1.compareTo(s2);

public class Main {

    public static void main(String[] args) {

        // 写法1
        String[] arr1 = {"Barbara", "James", "Mary", "John",
                "Patricia", "Robert", "Michael", "Linda"};
        Comparator<String> stringComparator1 = (s1, s2) -> s1.compareTo(s2);
        Arrays.sort(arr1, stringComparator1);
        for (String s : arr1) {
            System.out.println(s);
        }

        // 写法2 方法引用对应Lambda，Lambda的第一个参数会成为调用实例方法的对象
        // String::compareTo   int compareTo(String anotherString)
        // ===
        // (s1, s2) -> s1.compareTo(s2)
        String[] arr2 = {"Barbara", "James", "Mary", "John",
                "Patricia", "Robert", "Michael", "Linda"};
        Comparator<String> stringComparator2 = String::compareTo;
        Arrays.sort(arr2, stringComparator2);
        for (String s : arr2) {
            System.out.println(s);
        }
    }
}

5、Lambda在集合中的使用

forEach List接口

        ArrayList<String>list=new ArrayList<>();
        list.add("a");
        list.add("bc");
        list.add("def");
        list.add("hello");

        //写法1：（不用Lambda表达式）
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //写法2：（用Lambda表达式）
        list.forEach(s-> System.out.println(s));