java中方法支持lambda_【java新特性】之方法引用与Lambda表达式

在Lamda新特性的支持下，JAVA8中可以使用lamda表达式来创建匿名方法。然而，有时候我们仅仅是需要调用一个已存在的方法(如java中已经定义好的方法)，在这时候java8新特性“方法引用”将会进一步简化操作(注意：需要有Lamda的支持)。

方法引用的四种形式：

引用静态方法-->类名称::static 方法名称；

引用某个对象的实例的普通方法-->示例化对象::普通方法；

引用某个类型的任意对象的实例的普通方法-->特定类::普通方法；

引用构造方法-->类名称::new

引用静态方法

如：String类中的valueOf()方法：public static String valueOf(int x);

1 /**

2 * 实现方法的引用接口

3 * @param

引用方法的参数类型

4 * @param引用方法的返回类型

5 */

6 interface MyInterface

{

7 public R function(P p);//和String.valueOf(int x)类似

8 }

9

10 interfaceMyInterface1{

11 String function(Integer a);

12 }

13

14 public classMain {

15

16 public static voidtest(MyInterface1 myInterface1){

17 String result = myInterface1.function(2000);

18 System.out.println(result+" --");

19 }

20

21 public static voidmain(String[] args) {

22

23 //匿名内部类实现

24 test(newMyInterface1() {

25 @Override

26 publicString function(Integer a) {

27 returnString.valueOf(a);

28 }

29 });

30

31 //Lamda表达式实现

32 test((a)->String.valueOf(a));

33

34 //方法引用实现:引用类的静态方法

35 MyInterface msg =String::valueOf;

36 String str = msg.function(2000);

37 System.out.println(str);

38 }

39 }

引用某个对象的实例的普通方法

如：String类中的toUpperCase()方法：public String toUpperCase();

这个方法没有参数，但是有返回值，并且这个方法一定要在有实例化对象的时候才可以调用。

1 interface MyInterface2{

2 publicR upper();

3 }

4 public classMain1 {

5 public static voidmain(String[] args) {

6 String str = new String("hello");

7 MyInterface2 msg =str::toUpperCase;

8 System.out.println(msg.upper());//调用upper方法，就相当于调用toUpperCase方法

9 }

10 }

在上面的演示中已经发现，如果要实现方法的引用，就必须要有接口，并且这个接口中只能存在一个方法，否则方法是无法进行引用的。

所以为了保证被引用的接口里面只能够定义一个方法，就要在接口上加以限制，使用@FunctionalInterface 注解。

1 @FunctionalInterface //此为函数式接口，只能够定义一个方法

2 interface MyInterface2{

3 publicR upper();

4 }

引用某个类型的任意对象的实例的普通方法

比如：String类中的compareTo(String str1,String str2)方法 public int compareTo(String anotherString);

如果要进行比较的话，比较的形式：字符串1对象.compareTo(字符串2对象)，要准备两个参数。

1 @FunctionalInterface //此为函数式接口，只能够定义一个方法

2 interface MyInterface3

{

3 public intcompare(P p1,P p2);

4 }

5 public classMain2 {

6 public static voidmain(String[] args) {

7 MyInterface3 msg =String::compareTo;

8 System.out.println(msg.compare("A","B"));

9 }

10 }

与之前相比，方法引用前不需要再定义对象，而是可以理解为将对象定义在了参数中。

引用构造方法

1 @FunctionalInterface //此为函数式接口，只能够定义一个方法

2 interface MyInterface4{

3 public C person(String n,inta);

4 }

5 classPerson{

6 privateString name;

7 private intage;

8

9 public Person(String name, intage) {

10 this.name =name;

11 this.age =age;

12 }

13 @Override

14 publicString toString() {

15 return "姓名："+this.name+",年龄："+this.age;

16 }

17 }

18 public classMain3 {

19 public static voidmain(String[] args) {

20 MyInterface4 msg = Person::new;//引用构造方法

21 Person person = msg.person("小明",20);

22 System.out.println(person);

23 }

24 }