4 常见函数式接口

1. 使用Lambda的前提

必须有一个函数式接口

1. 有且只有一个抽象方法的接口
2. @FunctionalInterface注解

常见函数式接口

1. Runnable / Callable
2. Supplier / Consumer
3. Comparator
4. Predicate
5. Function

@FunctionalInterface
public interface IMathOperation {
	int operation(int a,int b);	
}

@FunctionalInterface
public interface IGreeting {	
	void sayHello(String message);
	
}

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

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

package com.threehigh.lambda;

public class RunnableLambda {
	
	public static void main(String[] args) {
		//使用匿名内部类的方式实现多线程
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				String name = Thread.currentThread().getName();
				System.out.println(name + " 线程已启动1");
			}
		}).start();
		/**
		 * todo 使用lambda表达式实现多线程
		 * Runnable接口只有一个run(),所以这里只有一个()，无需参数
		 * public abstract void run();
		 */
		new Thread(
				() -> {
					String name = Thread.currentThread().getName();
					System.out.println(name + " 线程已启动2");
				}
		).start();
	}
}

package com.threehigh.lambda;

import java.util.function.Supplier;

/**
 * 供应商接口
 * 求数组的最大值
 */
public class SupplierLambda {
	
	public static void main(String[] args) {
		
		int arr[] = {2,3,4,52,333,44};
		
		int max = getMax(() -> {
		
			int temp = arr[0];
			
			for(int i = 1 ;i< arr.length; i++) {
				if(arr[i] > temp) {
					temp = arr[i];
				}
			}
			return temp;
		});
		System.out.print(max);
	}
	
	public static int getMax(Supplier<Integer> sup) {
		return sup.get();
	}
	
}

public class ConsumerLambda {
	
	public static void main(String[] args) {
		consumerString(s -> System.out.println(s));
	}
	
	static void consumerString(Consumer<String> function) {
		function.accept("Hello");
		System.out.println("-------------------------");
		
		consumerString(
				f -> System.out.println(f.toUpperCase()),
				s -> System.out.println(s.toLowerCase())
				);
	}
	
	//andThen()
	static void consumerString(Consumer<String> first,Consumer<String> sec) {
		first.andThen(sec).accept("Hello ");
	}
	
}
//打印结果
Hello
-------------------------
HELLO 
hello 

import java.util.Arrays;
import java.util.Comparator;

public class CompartorLambda {
	
	public static void main(String[] args) {
		String[] strs = {"dfgdfgfdgh","abc","de","dfhgh"};
		//使用匿名内部类的方式，实现比较器
		Comparator<String> comparator = new Comparator<String>() {
			//自己实现比较的逻辑
			@Override
			public int compare(String o1, String o2) {
				return o1.length() - o2.length();
			}
		};
		Arrays.sort(strs,comparator);
		System.out.println(Arrays.toString(strs));
		System.out.println("=======================");
		
		//使用lambda表达式实现
		Arrays.sort(strs,(o1,o2) -> {
			return o1.length() - o2.length();
		});
		System.out.println(Arrays.toString(strs));
	}
}
//输出结果
[de, abc, dfhgh, dfgdfgfdgh]
=======================
[de, abc, dfhgh, dfgdfgfdgh]

import java.util.function.Predicate;

public class PredicateLambda {
	
	public static void main(String[] args) {
		
		andMethod(s -> s.contains("w"),
				  s -> s.contains("H"));
		
		orMethod( s -> s.contains("w"),
				  s -> s.contains("H"));
		
		negateMethod(
				  s -> s.contains("w")
				);
	}
	
	/**
	 * 两个参数进行判断，然后将结果进行与操作
	 * 结果同时成立：true
	 * @param one
	 * @param two
	 */
	static void andMethod(Predicate<String> one,Predicate<String> two) {
		boolean isValid = one.and(two).test("Helloworld");
		System.out.println("字符串符合要求吗：" + isValid);
	}
	
	/**
	 * 或操作
	 * @param one
	 * @param two
	 */
	static void orMethod(Predicate<String> one,Predicate<String> two) {
		boolean isValid = one.or(two).test("Helloworld");
		System.out.println("字符串符合要求吗：" + isValid);
	}
	
	/**
	 * 取反操作
	 * @param predicate
	 */
	static void negateMethod(Predicate<String> predicate) {
		boolean veryLong = predicate.negate().test("Helloworld");
		System.out.println("字符串很长吗：" + veryLong);
	}
}
//输出结果
字符串符合要求吗：true
字符串符合要求吗：true
字符串很长吗：false

import java.util.function.Function;

public class FunctionLambda {
	
	public static void main(String[] args) {
		
        method(str -> Integer.parseInt(str) + 10, i -> i *= 10);

        String str = "郑十,10";
        int age = getAgeNum(str, s -> s.split(",")[1],
                s -> Integer.parseInt(s),
                n -> n += 100);
        System.out.println(age);
    }

    static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
        int num = one.andThen(two).apply("10");
        System.out.println(num + 20);
    }

    static int getAgeNum(String str, Function<String, String> one,
                         Function<String, Integer> two,
                         Function<Integer, Integer> three) {
        return one.andThen(two).andThen(three).apply(str);
    }
}
//输出结果
220
110