怎么理解Java里的双冒号 “::”

“::”是什么？

在java中，双冒号“::”是方法引用的语法。方法引用是简化Lambda表达式的语法结构，使代码更简洁易懂，并且在使用引用方法时，会根据上下文推断参数类型，因此特别适用于直接引用已有方法的情况。

“::”的用法

ClassName::MethodName

其实，Class是包含静态方法methodName的类名，根据引用的方法类型不同，有不同的情况：

1.静态方法引用

假设我们有一个自定义的工具类MathUtil，其中就包含了一个静态方法square，用于计算一个整数的平方。现在我们想要计算一个整数列表中所有元素的平方和。

import java.util.Arrays;
import java.util.List;

public class MathUtil {


    public static int square(int num){
        System.out.println(num * num);
        return num * num;
    }

    public static int square(){
        System.out.println(1);
        return 1;
    }


    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1,2,3,4,5);
        int sum = numbers.stream().mapToInt(MathUtil::square).sum();
        System.out.println(sum);
    }
}

在上述方法中，我们通过使用静态方法引用MathUtil::square，将数组中的数组转成int类型，再使用mapToInt方法循环调用square(int num)方法，以便对列表中每个元素进行平方运算。

 

2.实例方法的引用

假设我们有一个字符串列表，我们想要按照字符串长度进行排序，我们可以使用Lambda表达式编写比较器，也可以使用实例方法引用简化代码。

import java.util.Arrays;
import java.util.List;

public class StringUtil {
    public static void main(String[] args) {
        List<String> phoneBrand = Arrays.asList("apple", "xiaomi", "huawei", "vivo", "oppo", "meizu");
        phoneBrand.sort((a,b) -> a.compareTo(b));
        System.out.println(phoneBrand); //[apple, huawei, meizu, oppo, vivo, xiaomi]

        //实例方法引入
        phoneBrand.sort(String::compareTo);
        System.out.println(phoneBrand); //[apple, huawei, meizu, oppo, vivo, xiaomi]
    }
}

在上述代码总，我们首先使用了Lambda编写了一个比较器进行字符串比较，然后又使用实例方法引用来简化比较器的写法，无需传递参数，直接调用方法，

 

3.对象方法引用

假设我们有一个自定义的Student类，其中包含姓名和年龄属性。我们想要根据student对象的年龄进行排序。

import com.alibaba.fastjson.JSON;
import java.util.Arrays;
import java.util.List;

public class ObjectUtil {


    public static void main(String[] args) {
        //示例1
        List<Student> students = Arrays.asList(
                new Student("小刘",18),
                new Student("小张",20),
                new Student("小王",22)
        );

        //使用Lambda编写比较器
        students.sort((s1,s2) -> s1.getAge() - s2.getAge());
        System.out.println(JSON.toJSONString(students));    //[{"age":18},{"age":20},{"age":22}]

        //使用对象方法引用
        students.sort(Student::compareAge);
        System.out.println(JSON.toJSONString(students));    //[{"age":18},{"age":20},{"age":22}]





        //示例2
        List<Integer> numbers = Arrays.asList(1,2,3,4,5);
        numbers.sort(ObjectUtil::sum);  //3----5----7----9----

    }

    //示例2
    public static int sum(int num1,int num2){
        System.out.print(num1 + num2 + "----");
        return num1 + num2;
    }

    //示例1
    static class Student {

        private String name;
        private int age;

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

        public int getAge() {
            return age;
        }

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

        public static int compareAge(Student s1, Student s2){
            return s1.getAge() - s2.getAge();
        }
    }
}

上述代码中，我们首先使用Lambda编写了一个比较器来根据年龄进行排序。然后我们又使用对象方法引用Student::compareAge来简化比较器的写法。其实个人觉得和实例方法引用没什么区别，无非就是一个引用自定义的，一个引用别人写好的。

4.构造方法引用

假设我们需要创建一个空的ArrayList，可以使用构造方法引用来实现。

import com.google.common.base.Supplier;
import java.util.ArrayList;
import java.util.List;

public class StructureUtil {
    public static void main(String[] args) {
        Supplier<List<String>> supplier = ArrayList::new;
        List<String> strings = supplier.get();
        System.out.println(strings instanceof List);    //true
    }
}