java8 方法引用

Love The Way You Lie 2022-06-10 01:37 180阅读 0赞

方法引用可以表示为调用特点方法的lambda表达式的一种快捷写法。方法引用就是根据已有的方法来创建lambda表达式，显示的指明方法的名称，这样可读性就更好。

当使用方法引用时，目标引用在::前，方法名称在后面。例如A::getNum。表示引用A中的方法getNum。方法不要加括号，因为没有实际调用这个方法。A::getNum就是(A a)->a.getNum()的简写。一些例子：

() -> Thread.currentThread().dumpStack()    Thread.currentThread()::dumpStack
     (str, i) -> str.substring(i)                String::substring
     (String s) -> System.out.println(s)         System.out::println
     (Integer i)-> Integer.intValue(i)           Integer::intValue

如何建立方法引用：主要有三类

1.指向静态方法的方法引用：例如Integer的parseInt方法，写作Integer::parseInt。  
       2.指向任意类型实例方法的方法引用：例如String的length方法，写作String::length。

3.指向现有对象的实例方法的方法引用：例如局部变量A a。他有getNum方法。那么就可以写为a::getNum。

第二种方法引用类似于你引用一个对象的方法，而那个对象是lambda表达式的一个参数，例如lambda表达式写为(String s)->s.length就可以写为String::length。

第三种方法引用就是你引用已经存在的外部对象的方法。例如：

public class Test {
       public static void main(String args[]) throws Exception {  
    	  A a = new A();
    	  new Thread(a::getNum).start();  
       }  
    }
    class A{
    	private int num=10;
    	public void getNum(){
    		System.out.println(num);
    	}
    }

构造方法的方法引用：格式为ClassName::new。

class A {
    	A(){}
    	A(int a){}
    	A(int a,String name){}
    }
    Supplier<A> s1 = A::new;  
    	   A a1 = s1.get();
    	   IntFunction<A> s2 = A::new;
    	   A a2 = s2.apply(10);
    	   BiFunction<Integer, String, A> s3 = A::new;  
    	   A a3 = s3.apply(10, "name");

构造参数超过三个，可以自定义函数式接口来实现。

不将构造函数实例化也能引用：

static Map<String, Function<Integer, A>> map = new HashMap<>();
    	static {
    		map.put("tom", A::new);
    		map.put("jack", A::new);
    	}
    
       public static A giveMeFruit(String name, Integer age){
    		return map.get(name.toLowerCase()).apply(20);
    	}

父类函数的方法引用：super::methodName

public class Test  extends A{
    	Test(){
    		new Thread(super::getNum).start();
    	}
    	public static void main(String[] args) {
    		new Test();
    	}
       
    }
    class A {
    	public void getNum(){
    		System.out.println("hello");
    	}
    }

数组构造函数的方法引用：typeName\[\]::new

IntFunction<int[]> function = int[]::new;
    		int[] is = function.apply(10);

复合的lambda表达式：

1.比较器复合

逆序：

public class Test {
    	public static void main(String[] args) {
    		List<Integer> list = new ArrayList<Integer>();
    		list.add(5);
    		list.add(7);
    		list.add(2);
    		list.sort(comparing(A::getNum).reversed());
    		
    		list.forEach(e->System.out.println(e));
    	}
       
    }
    class A {
    	public static int getNum(int a){
    		return a;
    	}
    }

比较器链：

public class Test {
    	public static void main(String[] args) {
    		List<Integer> list = new ArrayList<Integer>();
    		list.add(5);
    		list.add(7);
    		list.add(2);
    		list.sort(comparing(A::getNum).reversed().thenComparing(A::getNum));
    		
    		list.forEach(e->System.out.println(e));
    	}
       
    }
    class A {
    	public static int getNum(int a){
    		return a;
    	}
    }

2.谓词复合

negate、 and和or， 分别为非，与，或

Predicate<Apple> notRedApple = redApple.negate(); 
     Predicate<Apple> redAndHeavyApple =redApple.and(a -> a.getWeight() > 150);
     Predicate<Apple> redAndHeavyAppleOrGreen =redApple.and(a -> a.getWeight() > 150).or(a -> "green".equals(a.getColor()));

and和or方法是按照在表达式链中的位置，从左向右确定优先级的。因此， a.or(b).and(c)可以看作(a || b) && c。

3.函数复合

Function接口为此配了andThen和compose两个默认方法，它们都会返回Function的一个实例。

Function<Integer, Integer> f = x -> x + 1;
    Function<Integer, Integer> g = x -> x * 2;
    Function<Integer, Integer> h = f.andThen(g);
    int result = h.apply(1);

Function<Integer, Integer> f = x -> x + 1;
    Function<Integer, Integer> g = x -> x * 2;
    Function<Integer, Integer> h = f.compose(g);
    int result = h.apply(1);