Java常用新特性之方法引用

1.举例：

Comparator<Integer> com3 = Integer :: compare;

2.方法引用的理解

• 给接口提供实现类的对象，我们可以使用匿名实现类的对象的方式。
• 在此基础上，如果发现此接口是一个函数式接口，则给此接口提供实现类的对象，此时就一定可以使用lambda表达式
• 在此基础上，如果满足某个条件，我们就可以使用方法引用替换lambda表达式

3. 方法引用的本质：

方法引用作为了函数式接口的实现类的对象出现。 ----> 万事万物皆对象

4. 格式：

类(或对象) :: 方法名

5. 具体使用情况说明：

情况1：对象 :: 实例方法

• 接口要重写的抽象方法的形参列表和返回值类型与内部调用的某个类的对象的方法的形参列表和返回值类型一致
  （大部分情况下都是相同的），则可以使用某个类的对象的方法"替换"要重写的方法。

情况2：类 :: 静态方法

• 接口要重写的抽象方法的形参列表和返回值类型与内部调用的某个类的静态方法的形参列表和返回值类型一致（大部分情况下都是相同的），则可以使用某个类的对象的方法"替换"要重写的方法。

情况3：类 :: 实例方法 (难)

• 条件1：接口要重写的抽象方法的返回值类型与内部调用的某个类的对象的方法的返回值类型一致（大部分情况下都是相同的），
• 条件2：接口要重写的抽象方法的形参个数为n，内部调用的某个类的对象的方法a的形参个数为n-1，且接口要重写的抽象方法的的第1个形参即为方法a的调用者，且接口要重写的抽象方法的后n-1个参数即为方法a的n-1形参。

// 情况一：对象 :: 实例方法
	//Consumer中的void accept(T t)
	//PrintStream中的void println(T t)
	@Test
	public void test1() {
		//方式1：
		Consumer<String> con1 = new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		};

		//方式2：lambda表达式
		Consumer<String> con2 = s -> System.out.println(s);

		//方式3：方法引用
//		PrintStream ps = System.out;
//		Consumer<String> con3 = ps :: println;

		//或
		Consumer<String> con3 = System.out :: println;
		con3.accept("hello");

	}
	
	//Supplier中的T get()
	//Employee中的String getName()
	@Test
	public void test2() {

		Employee emp = new Employee(1004, "雷军", 26, 7657.37);

		//1.
		Supplier<String> sup1 = new Supplier<String>() {
			@Override
			public String get() {
				return emp.getName();
			}
		};

		System.out.println(sup1.get());

		//2.
		Supplier<String> sup2 = () -> emp.getName();

		//3.
		Supplier<String> sup3 = emp :: getName;

	}

	// 情况二：类 :: 静态方法
	//Comparator中的int compare(T t1,T t2)
	//Integer中的int compare(T t1,T t2)
	@Test
	public void test3() {
		//1.
		Comparator<Integer> com1 = new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return Integer.compare(o1,o2);
			}
		};

		//2.
		Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);

		//3.
		Comparator<Integer> com3 = Integer::compare;
		System.out.println(com3.compare(12, 32));
	}
	
	//Function中的R apply(T t)
	//Math中的Long round(Double d)
	@Test
	public void test4() {
		//1.
		Function<Double,Long> fun1 = d -> Math.round(d);

		//2.
		Function<Double,Long> fun2 = Math :: round;

	}

	// 情况三：类 :: 实例方法 
	// Comparator中的int comapre(T t1,T t2)
	// String中的int t1.compareTo(t2)
	@Test
	public void test5() {
		//1
		Comparator<String> com1 = new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		};
		//2
		Comparator<String> com2 = (o1,o2) -> o1.compareTo(o2);

		//3
		Comparator<String> com3 = String :: compareTo;

	}

	//BiPredicate中的boolean test(T t1, T t2);
	//String中的boolean t1.equals(t2)
	@Test
	public void test6() {
		//1.
		BiPredicate<String,String> b1 = new BiPredicate<String, String>() {
			@Override
			public boolean test(String s1, String s2) {
				return s1.equals(s2);
			}
		};

		//2.
		BiPredicate<String,String> b2 = (s1,s2) -> s1.equals(s2);

		//3.
		BiPredicate<String,String> b3 = String :: equals;

	}
	
	// Function中的R apply(T t)
	// Employee中的String getName();
	@Test
	public void test7() {
		//1
		Function<Employee,String> fun1 = new Function<Employee, String>() {
			@Override
			public String apply(Employee employee) {
				return employee.getName();
			}
		};
		//2
		Function<Employee,String> fun2 = emp -> emp.getName();

		//3.
		Function<Employee,String> fun3 = Employee::getName;

	}