java8 lambda表达式，方法的引用以及构造器的引用

叁歲伎倆 2021-09-27 03:26 395阅读 0赞

在前面有讲述过lambda表达式中，使用的都是函数式接口；关于lambda表达式简介[《java8 Lambda表达式简介》][java8 Lambda]；关于函数式接口[《java8 函数式接口简介》][java8]；

这篇主要是讲，在lambda表达式中，使用方法的引用，来传递方法方法的行为参数化；

方法的引用，在《java8实战》介绍如下：

方法的引用让你可以重复使用现有的方法定义，并像lambda一样传递他们，在一些情况下，比起使用lambda表达式，它们似乎更易读，感觉也更自然；

方法的引用的语法，主要有三类

1.指向静态方法的方法引用，例如Integer的parseInt方法 ，可以写成Integer::parseInt

类：：静态方法名

2.指向任意类型实例方法的方法引用，例如String的length方法，写成String::length；

类：：实例方法名

3.指向现有对象的实例方法的方法引用

对象：：实例方法名

构造器的引用：对于一个现有构造函数，你可以利用它的名称和关键字new来创建它的一个引用ClassName::new；

在java8中的函数式接口，提供了，无参构造函数，以及有参构造函数创建实例的方式；构造器的参数列表，需要与函数式接口中参数列表保持一致！

下面，我们用个小案例，来演示方法的引用以及构造器的引用

@Test
        public void test6() {
            /*************** 方法的引用 ****************/
            // 类：：静态方法名
            Comparator<Integer> bb = Integer::compare;
            System.out.println(bb.compare(3, 2));
            Comparator<Integer> cc = (x, y) -> Integer.compare(x, y);
            System.out.println(cc.compare(3, 2));
    
            Comparator<Integer> dd = (x, y) -> x.compareTo(y);
            System.out.println(dd.compare(3, 2));
            Comparator<Integer> ee = Integer::compareTo;
            System.out.println(ee.compare(3, 2));
            // 类：：实例方法名
            BiPredicate<String, String> bp = (x, y) -> x.equals(y);
            System.out.println(bp.test("a", "b"));
            BiPredicate<String, String> bp1 = String::equals;
            System.out.println(bp1.test("a", "b"));
    
            // 对象：：实例方法名
            Consumer<String> con1 = x -> System.out.println(x);
            con1.accept("abc");
            Consumer<String> con = System.out::println;
            con.accept("abc");
    
            Emp emp = new Emp("上海", "xiaoMIng", 18);
            Supplier<String> supper1 = () -> emp.getAddress();
            System.out.println(supper1.get());
            Supplier<String> supper = emp::getAddress;
            System.out.println(supper.get());
    
            /*************** 构造器的引用 ****************/
            // 无参构造函数，创建实例
            Supplier<Emp> supper2 = () -> new Emp();
            Supplier<Emp> supper3 = Emp::new;
            Emp emp1 = supper3.get();
            emp1.setAddress("上海");
            // 一个参数
            Function<String, Emp> fun = address -> new Emp(address);
            Function<String, Emp> fun1 = Emp::new;
            System.out.println(fun1.apply("beijing"));
            // 两个参数
            BiFunction<String, Integer, Emp> bFun = (name, age) -> new Emp(name, age);
            BiFunction<String, Integer, Emp> bFun1 = Emp::new;
            System.out.println(bFun1.apply("xiaohong", 18));
    
        }
    
        static class Emp {
            private String address;
    
            private String name;
    
            private Integer age;
    
            public Emp() {
    
            }
    
            public Emp(String address) {
                this.address = address;
            }
    
            public Emp(String name, Integer age) {
                this.name = name;
                this.age = age;
            }
    
            public Emp(String address, String name, Integer age) {
                super();
                this.address = address;
                this.name = name;
                this.age = age;
            }
    
            public String getAddress() {
                return address;
            }
    
            public void setAddress(String address) {
                this.address = address;
            }
    
            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 "Emp [address=" + address + ", name=" + name + ", age=" + age + "]";
            }
    
        }

最后，特别要注意：

①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！

②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

## 1.lambda表达式 ##

[《java8 Lambda表达式简介》][java8 Lambda]

[《java8 lambda表达式，方法的引用以及构造器的引用》][java8 lambda]

### 2.函数式接口 ###

[《java8 函数式接口简介》][java8]

[《JAVA8 Function接口以及同类型的特化的接口》][JAVA8 Function]

[《JAVA8 Consumer接口》][JAVA8 Consumer]

[《JAVA8 Supplier接口》][JAVA8 Supplier]

[《JAVA8 UnaryOperator接口》][JAVA8 UnaryOperator]

[《JAVA8 BiConsumer 接口》][JAVA8 BiConsumer]

3.stream接口操作

[《java8 Stream接口简介》][java8 Stream]

[《 java8 Stream-创建流的几种方式》][java8 Stream-]

[《JAVA8 stream接口 中间操作和终端操作》][JAVA8 stream_]

[《JAVA8 Stream接口，map操作，filter操作，flatMap操作》][JAVA8 Stream_map_filter_flatMap]

[《JAVA8 stream接口 distinct，sorted，peek，limit，skip》][JAVA8 stream_ distinct_sorted_peek_limit_skip]

[《java8 stream接口 终端操作 forEachOrdered和forEach》][java8 stream_ _ forEachOrdered_forEach]

[《java8 stream接口 终端操作 toArray操作》][java8 stream_ _ toArray]

[《java8 stream接口 终端操作 min，max，findFirst，findAny操作》][java8 stream_ _ min_max_findFirst_findAny]

[《java8 stream接口终端操作 count，anyMatch，allMatch，noneMatch》][java8 stream_ count_anyMatch_allMatch_noneMatch]

[《java8 srteam接口终端操作reduce操作》][java8 srteam_reduce]

[《java8 stream接口 终端操作 collect操作》][java8 stream_ _ collect]

4.其他部分

[《java8 Optional静态类简介，以及用法》][java8 Optional]

[java8 Lambda]: https://blog.csdn.net/qq_28410283/article/details/80961022
[java8]: https://blog.csdn.net/qq_28410283/article/details/80962325
[java8 lambda]: https://blog.csdn.net/qq_28410283/article/details/80963351
[JAVA8 Function]: https://blog.csdn.net/qq_28410283/article/details/80615629
[JAVA8 Consumer]: https://blog.csdn.net/qq_28410283/article/details/80618456
[JAVA8 Supplier]: https://blog.csdn.net/qq_28410283/article/details/80625482
[JAVA8 UnaryOperator]: https://blog.csdn.net/qq_28410283/article/details/80634319
[JAVA8 BiConsumer]: https://blog.csdn.net/qq_28410283/article/details/80704487
[java8 Stream]: https://blog.csdn.net/qq_28410283/article/details/80633292
[java8 Stream-]: https://blog.csdn.net/qq_28410283/article/details/80633710
[JAVA8 stream_]: https://blog.csdn.net/qq_28410283/article/details/80634725
[JAVA8 Stream_map_filter_flatMap]: https://blog.csdn.net/qq_28410283/article/details/80642786
[JAVA8 stream_ distinct_sorted_peek_limit_skip]: https://blog.csdn.net/qq_28410283/article/details/80643711
[java8 stream_ _ forEachOrdered_forEach]: https://blog.csdn.net/qq_28410283/article/details/80782808
[java8 stream_ _ toArray]: https://blog.csdn.net/qq_28410283/article/details/80783286
[java8 stream_ _ min_max_findFirst_findAny]: https://blog.csdn.net/qq_28410283/article/details/80783505
[java8 stream_ count_anyMatch_allMatch_noneMatch]: https://blog.csdn.net/qq_28410283/article/details/80783946
[java8 srteam_reduce]: https://blog.csdn.net/qq_28410283/article/details/80873910
[java8 stream_ _ collect]: https://blog.csdn.net/qq_28410283/article/details/81052881
[java8 Optional]: https://blog.csdn.net/qq_28410283/article/details/80952768