lamda表达式

双冒号 ::

JDK8中有双冒号的用法，就是把方法当做参数传到stream内部，使stream的每个元素都传入到该方法里面执行一下。

使用方法：

类名::方法名

例如：

表达式:

person -> person.getAge();

可以替换成

Person::getAge

表达式

() -> new HashMap<>();

可以替换成

HashMap::new

这种[方法引用]或者说[双冒号运算]对应的参数类型是Function<T,R> T表示传入类型，R表示返回类型。比如表达式person -> person.getAge(); 传入参数是person，返回值是person.getAge()，那么方法引用Person::getAge就对应着Function<Person,Integer>类型。 

以前的代码一般是如此的：

public class AcceptMethod {

    public static void  printValur(String str){
        System.out.println("print value : "+str);
    }

    public static void main(String[] args) {
        List<String> al = Arrays.asList("a","b","c","d");
        for (String a: al) {
            AcceptMethod.printValur(a);
        }
      //下面的for each循环和上面的循环是等价的 
        al.forEach(x->{
            AcceptMethod.printValur(x);
        });
    }
}

现在JDK双冒号是:

public class MyTest {
    public static void  printValur(String str){
        System.out.println("print value : "+str);
    }

    public static void main(String[] args) {
        List<String> al = Arrays.asList("a", "b", "c", "d");
        al.forEach(AcceptMethod::printValur);
        //下面的方法和上面等价的
        Consumer<String> methodParam = AcceptMethod::printValur; //方法参数
        al.forEach(x -> methodParam.accept(x));//方法执行accept
    }
}

Java 8 中我们可以通过  :: 关键字来访问类的构造方法，对象方法，静态方法。

class Something {

    // constructor methods
    Something() {}

    Something(String something) {
    System.out.println(something);
    }

    // static methods
    static String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }

    // object methods
    String endWith(String s) {
        return String.valueOf(s.charAt(s.length()-1));
    }

    void endWith() {}
}

如何用 ‘::’ 来访问类Something中的方法呢？先定义一个接口，因为必须要用 functional interface 来接收，否则编译错误（The target type of this expression must be a functional interface）

@FunctionalInterface
interface IConvert<F, T> {
    T convert(F form);
}

（@FunctionalInterface 注解要求接口有且只有一个抽象方法，JDK中有许多类用到该注解，比如 Runnable，它只有一个 Run 方法。）

观察接口 IConvert，传参为类型 F，返回类型 T。所以，我们可以这样访问类Something的方法：

访问静态方法

// static methods
IConvert<String, String> convert = Something::startsWith;
String converted = convert.convert("123");

访问对象方法

// object methods
Something something = new Something();
IConvert<String, String> converter = something::endWith;
String converted = converter.convert("Java");

访问构造方法

// constructor methods
IConvert<String, Something> convert = Something::new;
Something something = convert.convert("constructors");

总结

我们可以把类Something中的方法static String startsWith(String s){…}、String endWith(String s){…}、Something(String something){…}看作是接口IConvert的实现，因为它们都符合接口定义的那个“模版”，有传参类型F以及返回值类型T。比如构造方法Something(String something)，它传参为String类型，返回值类型为Something。注解@FunctionalInterface保证了接口有且仅有一个抽象方法，所以JDK能准确地匹配到相应方法。