JavaSE：Java8新特性 - 方法引用
1. 简介
方法引用：通过方法的名字，来指向一个方法。 （而不需要为方法引用提供方法体，该方法的调用交给函数式接口执行）
2. 方法引用使用一对冒号 :: 将类或对象与方法名进行连接， 通常使用方式如下：
<1> 对象的非静态方法引用 ObjectName :: MethodName
<2> 类的静态方法引用 ClassName :: StaticMethodName
<3> 类的非静态方法引用 ClassName :: MethodName
<4> 构造器的引用 ClassName :: new
<5> 数组的引用 TypeName[] :: new
3. 方法引用是在特定场景下，lambda表达式的一种简化表示，可以进一步简化代码的编写，
使代码更加紧凑简洁，从而减少冗余代码。
4. 代码示例
Person.java
2 3 public class Person implements Comparable<Person> { 4 private String name; 5 private int age; 6 7 public Person() { 8 } 9 10 public Person(String name, int age) { 11 this.name = name; 12 this.age = age; 13 } 14 15 public String getName() { 16 return name; 17 } 18 19 public void setName(String name) { 20 this.name = name; 21 } 22 23 public int getAge() { 24 return age; 25 } 26 27 public void setAge(int age) { 28 this.age = age; 29 } 30 31 public void show() { 32 System.out.println("没事出来秀一下哦"); 33 } 34 35 @Override 36 public String toString() { 37 return "Person{" + 38 "name='" + name + '\'' + 39 ", age=" + age + 40 '}'; 41 } 42 43 @Override 44 public int compareTo(Person o) { 45 //return getName().compareTo(o.getName()); 46 return getAge() - o.getAge(); 47 } 48 }
测试类
1 package com.lagou.task22; 2 3 import java.util.Arrays; 4 import java.util.Comparator; 5 import java.util.function.BiFunction; 6 import java.util.function.Consumer; 7 import java.util.function.Function; 8 import java.util.function.Supplier; 9 10 public class MethodReferenceTest { 11 12 public static void main(String[] args) { 13 14 // 1.使用匿名内部类的方式，通过函数式接口Runnable中的方法，实现对Person类中show()方法的调用 15 Person person = new Person("zhangfei", 30); 16 Runnable runnable = new Runnable() { 17 @Override 18 public void run() { 19 person.show(); 20 } 21 }; 22 runnable.run(); // 没事出来秀一下哦 23 24 System.out.println("-------------------------------------------------------------"); 25 // 2.使用lambda表达式的方式,实现Person类中show方法的调用 26 Runnable runnable1 = () -> person.show(); 27 runnable1.run(); // 没事出来秀一下哦 28 29 System.out.println("-------------------------------------------------------------"); 30 // 3.使用方法引用的方式实现Person类中show方法的调用 31 Runnable runnable2 = person::show; 32 runnable2.run(); 33 34 System.out.println("-------------------------------------------------------------");
35 // 4.使用匿名内部类的方式，通过函数式接口Consumer中的方法，来实现Person类中setName方法的调用 36 Consumer<String> consumer = new Consumer<String>() { 37 @Override 38 public void accept(String s) { 39 person.setName(s); 40 } 41 }; 42 consumer.accept("guanyu"); 43 System.out.println("person = " + person); // guanyu 30 44 45 System.out.println("-------------------------------------------------------------"); 46 // 5.使用lambda表达式的方式实现Person类中setName方法的调用 47 Consumer<String> consumer1 = s -> person.setName(s); 48 consumer1.accept("liubei"); 49 System.out.println("person = " + person); // liubei 30 50 51 System.out.println("-------------------------------------------------------------"); 52 // 6.使用方法引用的方式实现Person类中setName方法的调用 53 Consumer<String> consumer2 = person::setName; 54 consumer2.accept("zhangfei"); 55 System.out.println("person = " + person); // zhangfei 30 56 57 System.out.println("-------------------------------------------------------------"); 58 // 7.使用匿名内部类的方式，通过函数式接口Supplier中的方法，来实现Person类中getName方法的调用 59 Supplier<String> supplier = new Supplier<String>() { 60 @Override 61 public String get() { 62 return person.getName(); 63 } 64 }; 65 System.out.println(supplier.get()); // zhangfei 66 67 Supplier<String> supplier1 = () -> person.getName(); 68 System.out.println(supplier1.get()); // zhangfei 69 70 Supplier<String> supplier2 = person::getName; 71 System.out.println(supplier2.get()); // zhangfei 72 73 System.out.println("-------------------------------------------------------------");
74 // 8.使用匿名内部类的方式，通过函数式接口Function中的方法，实现Integer类中parseInt方法的调用 75 Function<String, Integer> function = new Function<String, Integer>() { 76 @Override 77 public Integer apply(String s) { 78 return Integer.parseInt(s); 79 } 80 }; 81 System.out.println(function.apply("12345")); // 12345 82 83 Function<String, Integer> function1 = s -> Integer.parseInt(s); 84 System.out.println(function1.apply("12345")); // 12345 85 86 Function<String, Integer> function2 = Integer::parseInt; 87 System.out.println(function2.apply("12345")); // 12345 88 89 System.out.println("-------------------------------------------------------------");
90 // 9.使用匿名内部类的方式通过函数式接口Comparator中的方法实现Integer类中compare方法的调用 91 Comparator<Integer> comparator = new Comparator<Integer>() { 92 @Override 93 public int compare(Integer o1, Integer o2) { 94 return Integer.compare(o1, o2); 95 } 96 }; 97 System.out.println(comparator.compare(10, 20)); // -1 98 99 Comparator<Integer> comparator1 = (o1, o2) -> Integer.compare(o1, o2); 100 System.out.println(comparator1.compare(10, 20)); // -1 101 102 Comparator<Integer> comparator2 = Integer::compare; 103 System.out.println(comparator2.compare(10, 20)); // -1 104 105 System.out.println("-------------------------------------------------------------"); 106 // 10.使用匿名内部类的方式通过类名来调用非静态方法 107 // 其中一个参数对象作为调用对象来调用方法时，可以使用上述方式 更抽象 108 Comparator<Integer> comparator3 = new Comparator<Integer>() { 109 @Override 110 public int compare(Integer o1, Integer o2) { 111 return o1.compareTo(o2); 112 } 113 }; 114 System.out.println(comparator3.compare(10, 20)); // -1 115 116 Comparator<Integer> comparator4 = (o1, o2) -> o1.compareTo(o2); 117 System.out.println(comparator4.compare(10, 20)); // -1 118 119 Comparator<Integer> comparator5 = Integer::compareTo; 120 System.out.println(comparator5.compare(10, 20)); // -1 121 122 System.out.println("-------------------------------------------------------------"); 123 // 11.使用匿名内部类的方式，通过Supplier函数式接口，创建Person类型的对象并返回 124 Supplier<Person> supplier3 = new Supplier<Person>() { 125 @Override 126 public Person get() { 127 return new Person(); 128 } 129 }; 130 System.out.println(supplier3.get()); // null 0 131 132 Supplier<Person> supplier4 = () -> new Person(); 133 System.out.println(supplier4.get()); // null 0 134 135 Supplier<Person> supplier5 = Person::new; 136 System.out.println(supplier5.get()); // null 0 137 138 System.out.println("-------------------------------------------------------------"); 139 // 12.使用匿名内部类的方式，通过BiFunction函数式接口采用有参方式，创建Person类型的对象并返回 140 BiFunction<String, Integer, Person> biFunction = new BiFunction<String, Integer, Person>() { 141 @Override 142 public Person apply(String s, Integer integer) { 143 return new Person(s, integer); 144 } 145 }; 146 System.out.println(biFunction.apply("zhangfei", 30)); // zhangfei 30 147 148 BiFunction<String, Integer, Person> biFunction1 = (s, integer) -> new Person(s, integer); 149 System.out.println(biFunction1.apply("zhangfei", 30)); // zhangfei 30 150 151 BiFunction<String, Integer, Person> biFunction2 = Person::new; 152 System.out.println(biFunction2.apply("zhangfei", 30)); // zhangfei 30 153 154 System.out.println("-------------------------------------------------------------"); 155 // 12.使用匿名内部类的方式，通过Function函数式接口，创建指定数量的Person类型的对象数组并返回 156 Function<Integer, Person[]> function3 = new Function<Integer, Person[]>() { 157 @Override 158 public Person[] apply(Integer integer) { 159 return new Person[integer]; 160 } 161 }; 162 Person[] pArr = function3.apply(3); 163 System.out.println(Arrays.toString(pArr)); 164 165 Function<Integer, Person[]> function4 = integer -> new Person[integer]; 166 System.out.println(Arrays.toString(function4.apply(4))); 167 168 Function<Integer, Person[]> function5 = Person[]::new; 169 System.out.println(Arrays.toString(function5.apply(5))); 170 } 171 }
