函数式接口

Function：函数型接口

接收参数，处理业务，返回结果

@FunctionalInterface
public interface Function<T, R> {
	//传入T，返回R
	R apply(T t);
}

//例子
public static void main(String[] args) {
	Function<Integer, String> function = new Function<Integer, String>() {
		@Override
		public String apply(Integer T) {
			//接收参数，处理业务，返回结果
			return String.valueOf(T);
		}
	};
	//Function<Integer, String> function = param -> String.valueOf(param);
	
	String R = function.apply(123);	//R = "123"
}

Predicate：断定型接口

给一个输入参数，返回布尔值

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

//例子
public static void main(String[] args) {
	Predicate<String> predicate = new Predicate<String>() {
		@Override
		public boolean test(String param) {
		//接收参数，返回true/false
			return param.equals("lenovo");
		}
	};
	//Predicate<String> predicate = param -> param.equals("lenovo");
	
	boolean r = predicate.test("lenovo")	//r = true
}

Supplier：供给型接口

没有参数，只有返回值

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

//例子
public static void main(String[] args) {
	Supplier<Integer> supplier = new Supplier<Integer>() {
	@Override
	public Integer get() {
		return new Random(10).nextInt();
	}
};
}

Consumer：消费型接口

只有一个输入参数，没有返回值

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

//例子
public static void main(String[] args) {
	Consumer<String> consumer1 = new Consumer<String>() {
		@Override
		public void accept(String s) {
			//接收参数，处理业务，没有返回值
			System.out.println(s);
	}
}