函数式接口

概念
函数式接口在java中指：有且仅有一个抽象方法的接口。
格式
确保接口中有且仅有一个抽象方法即可

修饰符 interface 接口名 {
public abstract 返回值类型 方法名称（可选参数信息）；

//其他非抽象方法内容（默认，静态,私有）
}

定义一个函数式接口

package functionalInterface;

/*
 * 函数式接口：有且仅有一个抽象方法的接口。
 * 当然接口中可以包含其他非抽象方法（默认，静态,私有）
 * 
 * @FunctionalInterface 注解 可以确保函数式接口定义正确，否则会报错
 * 
 */
@FunctionalInterface
public interface MyFunctionalInterface {

	public abstract void method1();
	//void method2();
}

实现它的某个类

package functionalInterface;

public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{


	@Override
	public void method1() {
		// TODO Auto-generated method stub
		
	}

}

在类中使用函数式接口。（函数式接口一般用作方法的参数和返回值类型）

package functionalInterface;
/*
 * 函数式接口的使用：一般可以作为方法的参数和返回类型，如下。
 */
public class myDemo1 {
	//定义一个方法，参数使用函数式接口MyFunctionalInterface
	public static void show(MyFunctionalInterface myImpl) {
		myImpl.method1();
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//调用show方法，方法的参数是一个接口，所以可以传递接口的实现类对象
		show(new MyFunctionalInterfaceImpl());
		//调用show方法，方法的参数是一个接口，所以可以传递接口的匿名内部类
		show(new MyFunctionalInterface() {
			@Override
			public void method1() {
				// TODO Auto-generated method stub
				System.out.println("使用匿名内部类重写接口中的抽象方法。");
			}
			
		});
		//Lambda表达式
		show(()-> {
			System.out.println("使用Lambda表达式重写接口中的抽象方法");
		});
		//简化Lambda表达式。
		//接口只有一个抽象方法，故可使用该表达式，抽象方法中仅一个形参，故可省略，只输出一句话，故大括号和分号都可省略
		show(()-> System.out.println("使用简化后的Lambda表达式重写接口中的抽象方法。") );
	}
	

}

函数式接口主要用于在形参中。

使用场景1
调用一个方法showLog(int level，String msg)显示日志信息，要求level=1时才显示msg信息，假若有三条msg，那么首先需要把三个字符串拼接，然后调用showLog()方法。
若所传字符串level≠1，则字符串拼接造成了资源浪费，此时就可将形参String msg用函数式接口作为参数代替。接口中定义一个抽象方法。在showLog方法中调用该形参的方法，该方法中在main方法中重写。即传入的参数level是否为1？是->调用抽象方法，抽象方法中返回字符串拼接，并将返回的字符串打印。不是->不做操作，也就不拼接字符串。

public class Demo01Logger {

	public static void showLog(int level, String message) {
		//对日志等级进行判断
		if(level ==1) {
			System.out.println(message);
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//定义三个日志信息
		String msg1 = "hello";
		String msg2 = "world";
		showLog(1,msg1+msg2);
	}

使用场景2

package functionalInterface2;

public class FunctionalInterface3 {

	public static void main(String[] args) {
		//方法的参数是一个接口，则我们可以传递这个接口的匿名内部类
		startThread(()->System.out.println(Thread.currentThread().getName()+" 线程启动"));
		startThread(()->System.out.println(Thread.currentThread().getName()+" 线程启动"));
		startThread(()->System.out.println(Thread.currentThread().getName()+" 线程启动"));
	}

	//定义一个方法，方法的参数使用函数式接口Runnable
	private static void startThread(Runnable r) {
		// TODO Auto-generated method stub
		new Thread(r).start();//开启线程
		
	}
}

使用场景3（函数式接口用作返回参数）
以下例子需要将字符串数组arr按照字符串的长度倒序排序，故实现comparator接口，需要重写里面的唯一方法。

package functionalInterface2;

import java.util.Arrays;
import java.util.Comparator;
/*
 * 如果一个方法的韩绘制类型是一个函数式接口，那么久可以直接返回一个Lambda表达式
 * 当需要通过一个方法来获取java.util.Comparator接口类型的对象作为排序器时，就可以调用该方法获取
 * 
 */
public class FunctionalInterface {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] arr = {"aaaaaa","cc","ff","bbbbbb","eeee","g"};
		//输出排序前的数组
		System.out.println(Arrays.toString(arr));
		//给数组排序
		Arrays.sort(arr, getMyComparator());
		System.out.println(Arrays.toString(arr));
	}

	public static Comparator<String> getMyComparator(){
		//方法1：定义一个方法，方法的返回值类型使用函数式接口Comparator
		/*return new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				// TODO Auto-generated method stub
				//按照字符串的降序排序
				return o2.length()-o1.length();
			}
		};	*/
		//方法2：方法的返回值是一个函数式接口，所以可以返回一个Lambda表达式
		/*return(String o1, String o2)->{
			return o2.length()-o1.length();
		};*/
		
		//方法2优化Lambda表达式
		return (o1,o2)->o2.length()-o1.length();

	}	
	
}

输出结果：
[aaaaaa, cc, ff, bbbbbb, eeee, g]
[aaaaaa, bbbbbb, eeee, cc, ff, g]