java--lambda表达式进阶版--方法引用与构造器引用

最新推荐文章于 2024-01-06 18:10:43 发布

运维小菜

最新推荐文章于 2024-01-06 18:10:43 发布

阅读量115

点赞数 1

分类专栏： java 文章标签： lambda java

本文链接：https://blog.csdn.net/lzq00277/article/details/117717991

版权

java 专栏收录该内容

25 篇文章 1 订阅

订阅专栏

本文详细介绍了Java 8中引入的方法引用、构造器引用和数组引用特性，通过示例展示了如何使用这些引用类型简化代码，包括对象实例方法、类静态方法、对象构造器以及数组创建的引用方式。这些特性是Lambda表达式的补充，旨在提高代码的简洁性和可读性。

摘要由CSDN通过智能技术生成

一、方法引用

方法引用的几种形式：

方法引用与原始实现接口的方式比较：

[对象::实例方法]：接口中的方法的方法体只有一行，且为对象.实例方法()的形式,此实例方法的参数列表一样，返回值类型一样
[类::静态方法]：接口中的方法的方法体只有一行，且为类.静态方法()的形式,此静态方法的参数列表一样，返回值类型一样
[类::实例方法]：接口中的方法的方法体只有一行，且为对象.实例方法(*)的形式,此对象即为接口方法的第一个参数

package methodReferences;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class MethodReferenceTest {
    @Test // [对象::方法]：接口中的方法的方法体只有一行，且为对象.对象方法()的形式,此对象方法的参数列表一样，返回值类型一样
    public void MethodReference1(){
        // 常规方式
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) { // println方法与accept方法参数列表一样，都无返回值
                System.out.println(s); // func方法体只有一行，直接执行 println()
            }
        };
        consumer.accept("Beijing");

        // lambda方式
        Consumer<String> cons = str -> System.out.println(str);
        cons.accept("Shanghai");

        // 方法引用方式
        Consumer<String> c = System.out::println;
        c.accept("Shenzhen");
    }

    @Test // [对象::方法]：接口中的方法的方法体只有一行，且为[return 对象.对象方法()]的形式,此对象方法的参数列表一样，返回值类型一样
    public void MethodReference2(){
        Runner lh = new Runner("李华", 22,11);

        // 常规方式
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() { // getName方法与get方法都无形参，返回值类型都为String
                return lh.getName(); // func方法体只有一行，直接return speedArea()
            }
        };
        System.out.println(supplier.get());

        // lambda方式
        Supplier<String> sup = () -> lh.getName();
        System.out.println(sup.get());

        // 方法引用方式
        Supplier<String> c = lh::getName;
        System.out.println(c.get());
    }

    @Test // [类::方法]：接口中的方法的方法体只有一行，且为类.静态方法()的形式,此静态方法的参数列表一样，返回值类型一样
    public void MethodReference3(){
        // 常规方式
        CommonInterface commonInterface = new CommonInterface() {
            @Override
            public int func(int i, int j) { // speedArea方法与func方法形参列表一样，返回值类型一样
                return Runner.speedArea(i ,j); // func方法体只有一行，直接return speedArea()
            }
        };
        System.out.println(commonInterface.func(5, 15));

        // lambda方式
        CommonInterface comInter = (i, j) -> Runner.speedArea(i,j);
        System.out.println(comInter.func(5, 6));

        // 方法引用方式
        CommonInterface ci = Runner::speedArea;
        System.out.println(ci.func(12, 14));
    }

    @Test // [类::方法]：接口中的方法的方法体只有一行，且为对象.实例方法(*)的形式,此对象即为接口方法的第一个参数
    public void MethodReference4(){
        // 常规方式
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) { // 第一个参数作为调用者
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator.compare("bb", "aa"));

        // lambda方式
        Comparator<String> compt = (o1,o2) -> o1.compareTo(o2);
        System.out.println(compt.compare("aa", "bb"));

        // 方法引用方式
        Comparator<String> c = String::compareTo; // 类名::方法名
        System.out.println(c.compare("aa", "aa"));
    }
}

class Runner{
    private String name;
    private int age;
    private static int commonSpeed = 10;
    public Runner(String name, int age, int speed) {
        this.name = name;
        this.age = age;
    }

    public void whatTime(String time){
        System.out.println("running in the "+ time);
    }

    // 无需关注方法逻辑，只关注返回值类型和形参列表即可
    public static int speedArea(int a,int b){
        if (commonSpeed > b){
            return 1;
        }else if(commonSpeed < a){
            return -1;
        }else {
            return 0;
        }
    }
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

interface CommonInterface{
    int func(int i,int j);
}

二、构造器引用

[类::new]：接口中的方法的方法体只有一行，即构造一个该方法的返回值类型的对象，并且该方法形参列表与返回值类构造器的形参列表一致

package methodReferences;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class MethodReferenceTest {

    @Test // [类::new]：接口中的方法的方法体只有一行，即构造一个该方法的返回值类型的对象，并且该方法形参列表与返回值类构造器的形参列表一致
    public void MethodReference5(){
        // 常规方式
        CommonInterface commonInterface = new CommonInterface() {
            @Override
            public Runner func(String str, int i, int j) { // Runner构造器与func方法形参列表一样，func返回值为Runner
                return new Runner(str,i ,j); // func方法体只有一行，直接return Runner实例
            }
        };
        System.out.println(commonInterface.func("wlh", 11, 22).getName());


        // lambda方式
        CommonInterface comInt = (str, i, j) -> new Runner(str, i, j);
        System.out.println(comInt.func("zjl", 22, 33).getName());

        // 构造器引用方式
        CommonInterface ci = Runner::new;
        System.out.println(ci.func("zxy", 33, 44).getName());
    }

class Runner{
    private String name;
    private int age;
    private static int commonSpeed = 10;

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

    public String getName() {
        return name;
    }
}

interface CommonInterface{
    Runner func(String str,int i,int j);
}

三、数组引用

[类[]::new]：接口中的方法的方法体只有一行，即构造一个该方法的返回值类型的对象数组

package methodReferences;

import org.junit.Test;


public class MethodReferenceTest {

    @Test // [类[]::new]：接口中的方法的方法体只有一行，即构造一个该方法的返回值类型的对象数组
    public void MethodReference6(){
        // 常规方式
        CommonInterface1 commonInterface1 = new CommonInterface1() {
            @Override
            public Runner[] func(int j) { // 参数为数组对象的个数
                return new Runner[j];  // 返回一个对象数组
            }
        };

        // lambda方式
        CommonInterface1 comInt1 = j ->new Runner[j];

        // 构造器引用方式
        CommonInterface1 ci1 = Runner[]::new;
        Runner[] runners = ci1.func(5);
        for (Runner r:runners) {
            System.out.println(r);
        }
    }
}

class Runner{
    private String name;
    private int age;
    private static int commonSpeed = 10;

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

    public String getName() {
        return name;
    }
}


interface CommonInterface1{
    Runner[] func(int j);
}