Java8 内置的四大核心函数式接口

 Java8中内置了以下4种

函数名	函数简述	函数成员方法	描述
Consumer<T>	消费型接口	void accept(T t);	将传入参数做相应的逻辑处理，无返回值。
Supplier<T>	供给型接口	T get();	做相应的逻辑处理，返回一个对象，可以用来生成 集合 ，数组 等等
Function<T, R>	函数型接口	R apply(T t);	根据传入的参数，做相应的逻辑处理，返回一个处理结果
Predicate<T>	断言型接口	boolean test(T t);	根据传入的参数，做相应的逻辑处理，返回一个布尔值，可以用在集合的过滤等操作。

  这些接口可以搭配lambda表达式使用，起到简化代码的效果。

代码示例：

    //Consumer<T> 消费型接口 :
	@Test

	public void test1(){
        //使用 主要参数的传递
		look(0, (m) -> System.out.println("看阿咚的博客需要只需花费：" + m + "元,请点赞"));
	} 
	//目标方法
	public void look(double money, Consumer<Double> con){
		con.accept(money);
	}

//控制台输出 ： 看阿咚的博客需要只需花费：0.0元,请点赞
-----------------------------------------------------------------------
//Supplier<T> 供给型接口 :
	@Test
	public void test2(){
        //使用
		List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
		//输出
        for (Integer num : numList) {
			System.out.print(num+" ,");
		}
	}
	
	//目标方法 需求：产生指定个数的整数，并放入集合中
	public List<Integer> getNumList(int num, Supplier<Integer> sup){
		List<Integer> list = new ArrayList<>();
		for (int i = 0; i < num; i++) {
			Integer n = sup.get();
			list.add(n);
		}
		return list;
	}
//控制台输出 ：19 ,40 ,55 ,59 ,15 ,32 ,86 ,43 ,66 ,24 ,
---------------------------------------------------------------------
	//Function<T, R> 函数型接口：
	@Test
	public void test3(){
        //使用
		String newStr = strHandler("\t\t\t 跟阿咚学Java，很简单   ", (str) -> str.trim());
		System.out.println(newStr);
		
		String subStr = strHandler("跟阿咚学Java，很简单", (str) -> str.substring(1, 3));
		System.out.println(subStr);
	}
	
	//目标方法   需求：用于处理字符串
	public String strHandler(String str, Function<String, String> fun){
		return fun.apply(str);
	}
//控制台输出 ：跟阿咚学Java，很简单
              阿咚
-----------------------------------------------------------------------------------
//Predicate<T> 断言型接口：
	@Test
	public void test4(){
		List<String> list = Arrays.asList("Hello", "阿咚", "do懂");
        //使用
		List<String> strList = filterStr(list, (s) -> s.length() > 3);
		for (String str : strList) {
			System.out.println(str);
		}
	}
	
   //目标方法 
	//需求：将满足条件的字符串，放入集合中
	public List<String> filterStr(List<String> list, Predicate<String> pre){
		List<String> strList = new ArrayList<>();
		for (String str : list) {
			if(pre.test(str)){
				strList.add(str);
			}
		}
		return strList;
	}
//控制台输出 ：Hello

除上以外，还提供了 大量的扩展接口 ，使用方式与上边都大同小异。

1,BiConsumer<T,U>
代表了一个接受两个输入参数的操作，并且不返回任何结果

2    BiFunction<T,U,R>
代表了一个接受两个输入参数的方法，并且返回一个结果

3    BinaryOperator<T>
代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果

4    BiPredicate<T,U>
代表了一个两个参数的boolean值方法

5    BooleanSupplier
代表了boolean值结果的提供方

6    Consumer<T>
代表了接受一个输入参数并且无返回的操作

7    DoubleBinaryOperator
代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。

8    DoubleConsumer
代表一个接受double值参数的操作，并且不返回结果。

9    DoubleFunction<R>
代表接受一个double值参数的方法，并且返回结果

10    DoublePredicate
代表一个拥有double值参数的boolean值方法

11    DoubleSupplier
代表一个double值结构的提供方

12    DoubleToIntFunction
接受一个double类型输入，返回一个int类型结果。

13    DoubleToLongFunction
接受一个double类型输入，返回一个long类型结果

14    DoubleUnaryOperator
接受一个参数同为类型double,返回值类型也为double 。

15    Function<T,R>
接受一个输入参数，返回一个结果。

16    IntBinaryOperator
接受两个参数同为类型int,返回值类型也为int 。

17    IntConsumer
接受一个int类型的输入参数，无返回值 。

18    IntFunction<R>
接受一个int类型输入参数，返回一个结果 。

19    IntPredicate
：接受一个int输入参数，返回一个布尔值的结果。

20    IntSupplier
无参数，返回一个int类型结果。

21    IntToDoubleFunction
接受一个int类型输入，返回一个double类型结果 。

22    IntToLongFunction
接受一个int类型输入，返回一个long类型结果。

23    IntUnaryOperator
接受一个参数同为类型int,返回值类型也为int 。

24    LongBinaryOperator
接受两个参数同为类型long,返回值类型也为long。

25    LongConsumer
接受一个long类型的输入参数，无返回值。

26    LongFunction<R>
接受一个long类型输入参数，返回一个结果。

27    LongPredicate
R接受一个long输入参数，返回一个布尔值类型结果。

28    LongSupplier
无参数，返回一个结果long类型的值。

29    LongToDoubleFunction
接受一个long类型输入，返回一个double类型结果。

30    LongToIntFunction
接受一个long类型输入，返回一个int类型结果。

31    LongUnaryOperator
接受一个参数同为类型long,返回值类型也为long。

32    ObjDoubleConsumer<T>
接受一个object类型和一个double类型的输入参数，无返回值。

33    ObjIntConsumer<T>
接受一个object类型和一个int类型的输入参数，无返回值。

34    ObjLongConsumer<T>
接受一个object类型和一个long类型的输入参数，无返回值。

35    Predicate<T>
接受一个输入参数，返回一个布尔值结果。

36    Supplier<T>
无参数，返回一个结果。

37    ToDoubleBiFunction<T,U>
接受两个输入参数，返回一个double类型结果

38    ToDoubleFunction<T>
接受一个输入参数，返回一个double类型结果

39    ToIntBiFunction<T,U>
接受两个输入参数，返回一个int类型结果。

40    ToIntFunction<T>
接受一个输入参数，返回一个int类型结果。

41    ToLongBiFunction<T,U>
接受两个输入参数，返回一个long类型结果。

42    ToLongFunction<T>
接受一个输入参数，返回一个long类型结果。

43    UnaryOperator<T>
接受一个参数为类型T,返回值类型也为T。