JAVA8新特性(三)——方法引用

刺骨的言语ヽ痛彻心扉 2022-06-08 05:18 219阅读 0赞

我们之前写Lambda表达式，如果Lambda表达式有对应方法，我们可以直接引用方法作为Lambda表达式。这种做法叫做方法引用。方法引用用”::”分隔。

例子

@Test
    public void methodRefTest() {
        MethodReference.Class1 class1 = new MethodReference.Class1();
        double result = doubleUnatuOperator(4.5, class1::return1);
        System.out.println("result:" + result);
    }
    
    public double doubleUnatuOperator(double num, DoubleUnaryOperator doubleUnaryOperator) {
        return doubleUnaryOperator.applyAsDouble(num);
    }
    static class Class1 {
    
        public double return1(double i) {
            return 1 + i;
        }
    
    }

这里doubleSupplier的表达式调用Class1.return1方法，就可以使用方法引用。

方法引用有四种

引用静态方法

ContainingClass::staticMethodName

例子: String::valueOf，对应的Lambda：(s) -> String.valueOf(s)

比较容易理解，和静态方法调用相比，只是把.换为::

引用特定对象的实例方法

containingObject::instanceMethodName

例子: x::toString，对应的Lambda：() -> this.toString()

与引用静态方法相比，都换为实例的而已

引用构造函数

ClassName::new

例子: String::new，对应的Lambda：() -> new String()

构造函数本质上是静态方法，只是方法名字比较特殊。

引用特定类型的任意对象的实例方法

这个不清楚

例子

public class MethodReference {
    
        @Test
        public void staticMethodRefTest() {
            double result = doubleUnatuOperator(4.5, Class1::staticReturn1);
            System.out.println("result:" + result);
        }
    
        @Test
        public void methodRefTest() {
            MethodReference.Class1 class1 = new MethodReference.Class1();
            double result = doubleUnatuOperator(4.5, class1::return1);
            System.out.println("result:" + result);
        }
    
        @Test
        public void constructorRefTest() {
            Class1 class1 = supplier(Class1::new);
            System.out.println(class1);
        }
    
        @Test
        public void ContainingTypeRefTest() {
            String[] stringArray = {"Barbara", "James", "Mary", "John",
                    "Patricia", "Robert", "Michael", "Linda"};
            Arrays.sort(stringArray, (a, b) -> {
                return a.compareToIgnoreCase(b);
            });
            System.out.println(Arrays.toString(stringArray));
            Arrays.sort(stringArray, String::compareToIgnoreCase);
            System.out.println(Arrays.toString(stringArray));
            
        }
    
        public static double doubleUnatuOperator(double num, DoubleUnaryOperator doubleUnaryOperator) {
            return doubleUnaryOperator.applyAsDouble(num);
        }
    
        public Object unaryOperator(Object t,UnaryOperator<Object> operator) {
            return operator.apply(t);
        }
    
        public Class1 supplier(Supplier<Class1> supplier) {
            return supplier.get();
        }
    
    
        static class Class1 {
    
            private String name;
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public Class1() {
    
            }
    
            public Class1(String name) {
                System.out.println(name + "构造成功");
            }
    
            public double return1(double i) {
                return 1 + i;
            }
    
            public static double staticReturn1(double i) {
                return i + 1;
            }
    
            public double add(Class1 a) {
                return 12.0;
            }
    
            @Override
            public String toString() {
                return "Class1{" +
                        "name='" + name + '\'' +
                        '}';
            }
        }
    }