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 }

 

posted @ 2021-06-29 12:15  Jasper2003  阅读(72)  评论(0编辑  收藏  举报