java8 方法引用

       方法引用可以表示为调用特点方法的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();  <!--引用的方法要符合函数描述符，runnable为()->void,getNum也为()->void-->
   }  
}
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;<!--根据一个int参数的构造方法构造-->
	   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));
		<!--thenComparing是在前一个排序相同的情况下，再根据另一个条件排序-->
		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(); <!--表示不是redApple-->
 Predicate<Apple> redAndHeavyApple =redApple.and(a -> a.getWeight() > 150);<!--表示redApple并且重量大于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);<!--表示先执行f，然后把结果传给g，所以得到结果为4-->

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);<!--表示先算g，后算f，所以结果为3-->