四大函数式接口

lambda表达式
链式编程
Stream式计算
函数式接口

函数式接口

@FunctionalInterface
public interface Runnable {
    
    
    public abstract void run();
}

//简化编程模型 
//forEach就是消费函数式接口

Function接口 （函数型接口） 传入一个参数，返回一个参数

	public static void main(String[] args) {
    
    
		//工具类：输出输入的值
//		 = new Function<String, String>() {
    
    
//			@Override
//			public String apply(String t) {
    
    
//				return t;
//			}
//		};
		
		//保留可读性的情况下，使用lambda表达式
		Function<String, String> function = (t)->{
    
    
			return t;
		};
		
		System.out.println(function.apply("1"));
		
	}

Predicate接口 （断定型接口）传入一个参数，返回Boolean

	public static void main(String[] args) {
    
    
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "");
		
		Predicate<Map<Integer, String>> predicate = new Predicate<Map<Integer, String>>() {
    
    
			@Override
			public boolean test(Map<Integer, String> m) {
    
    
				return m.get(1).isEmpty();
			}
		};
		
		Predicate<Map<Integer, String>> predicate1 = m->m.get(1).isEmpty();
		
		System.out.println(predicate1.test(map));
	}

Consumer接口（消费型接口）传入一个参数

	public static void main(String[] args) {
    
    
		
		Consumer<String> consumer = new Consumer<String>() {
    
    
			@Override
			public void accept(String t) {
    
    
				System.out.println(t);
			}
		};
		
		Consumer<String> consumer2 = t->System.out.println(t);
		
		consumer2.accept("fk");
		consumer.accept("you");
	}

Supplier（供给型接口） 返回一个参数

	public static void main(String[] args) throws AWTException {
    
    
		Robot robot = new Robot();
		Supplier<?> supplier = new Supplier<Object>() {
    
    
			Robot robot = new Robot();
			@Override
			public Object get() {
    
    
				robot.mouseMove(10000, 10000);
				return true;
			}
		};
		
		Supplier<?> supplier1 = ()->{
    
    robot.mouseMove(100, 100);return true;};
		
		supplier1.get();
		try {
    
    
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
    
    
			e.printStackTrace();
		}
		supplier.get();
	}