不灭的焱

革命尚未成功,同志仍须努力下载JDK17

作者:php-note.com  发布于:2022-05-03 22:10  分类:Java基础  编辑

 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

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

函数名 函数成员方法 描述
BiConsumer<T,U>   代表了一个接受两个输入参数的操作,并且不返回任何结果
BiFunction<T,U,R>   代表了一个接受两个输入参数的方法,并且返回一个结果
BinaryOperator<T>   代表了一个作用于于两个同类型操作符的操作,并且返回了操作符同类型的结果
BiPredicate<T,U>   代表了一个两个参数的boolean值方法
BooleanSupplier   代表了boolean值结果的提供方
Consumer<T>   代表了接受一个输入参数并且无返回的操作
DoubleBinaryOperator   代表了作用于两个double值操作符的操作,并且返回了一个double值的结果。
DoubleConsumer   代表一个接受double值参数的操作,并且不返回结果。
DoubleFunction<R>   代表接受一个double值参数的方法,并且返回结果
DoublePredicate   代表一个拥有double值参数的boolean值方法
DoubleSupplier   代表一个double值结构的提供方
DoubleToIntFunction   接受一个double类型输入,返回一个int类型结果。
DoubleToLongFunction   接受一个double类型输入,返回一个long类型结果
DoubleUnaryOperator   接受一个参数同为类型double,返回值类型也为double 。
Function<T,R>   接受一个输入参数,返回一个结果。
IntBinaryOperator   接受两个参数同为类型int,返回值类型也为int 。
IntConsumer   接受一个int类型的输入参数,无返回值 。
IntFunction<R>   接受一个int类型输入参数,返回一个结果 。
IntPredicate   接受一个int输入参数,返回一个布尔值的结果。
IntSupplier   无参数,返回一个int类型结果。
IntToDoubleFunction   接受一个int类型输入,返回一个double类型结果 。
IntToLongFunction   接受一个int类型输入,返回一个long类型结果。
IntUnaryOperator   接受一个参数同为类型int,返回值类型也为int 。
LongBinaryOperator   接受两个参数同为类型long,返回值类型也为long。
LongConsumer   接受一个long类型的输入参数,无返回值。
LongFunction<R>   接受一个long类型输入参数,返回一个结果。
LongPredicate   R接受一个long输入参数,返回一个布尔值类型结果。
LongSupplier   无参数,返回一个结果long类型的值。
LongToDoubleFunction   接受一个long类型输入,返回一个double类型结果。
LongToIntFunction   接受一个long类型输入,返回一个int类型结果。
LongUnaryOperator   接受一个参数同为类型long,返回值类型也为long。
ObjDoubleConsumer<T>   接受一个object类型和一个double类型的输入参数,无返回值。
ObjIntConsumer<T>   接受一个object类型和一个int类型的输入参数,无返回值。
ObjLongConsumer<T>   接受一个object类型和一个long类型的输入参数,无返回值。
 Predicate<T>   接受一个输入参数,返回一个布尔值结果。
Supplier<T>   无参数,返回一个结果。
ToDoubleBiFunction<T,U>   接受两个输入参数,返回一个double类型结果
ToDoubleFunction<T>   接受一个输入参数,返回一个double类型结果
ToIntBiFunction<T,U>   接受两个输入参数,返回一个int类型结果。
ToIntFunction<T>   接受一个输入参数,返回一个int类型结果。
ToLongBiFunction<T,U>   接受两个输入参数,返回一个long类型结果。
ToLongFunction<T>   接受一个输入参数,返回一个long类型结果。
UnaryOperator<T>   接受一个参数为类型T,返回值类型也为T。

 

 




 

Java 8 函数式接口

JDK 8 也有一段时间了,这个过程中也不免用到一些函数式接口,这里简单做个总结。

函数式接口:为了支持将lambda表达式作为参数传入接口中,Java 8 定义了函数式接口的概念,函数式接口一般只有一个抽象的方法,并且通过@FunctionalInterface标记。

在日常开发中,如果我们想让自己定义的方法支持传入一个lambda表达式,有两种方法可以做到:

  • 自己定义一个函数式接口
  • 使用JDK自带的函数式接口

一般来说,都推荐第二种,因为JDK自带函数式接口基本都能满足日常所用。并且使用通用的接口能让你的API更加通俗,减少其他人阅读源码时的不必要的学习。并且JDK自带的函数式接口提供了很多通用的的默认方法。

JDK一共提供了43个函数式接口,不过分类来看差不多有4类,记住这4类中每一类最通用的接口便能理解其他的接口,他们分别为:

  • Function<T>函数类接口,此接口方法接收参数,并返回结果
    • Operator<T>操作类接口,特殊的函数类接口,此接口方法的参数和结果类型相同
  • Predicate<T>断言类接口,此接口接受一个参数并返回一个布尔值
  • Supplier<T>生产类接口,此接口不接受参数,但是会有返回值
  • Consumer<T>消费类接口,此接口只接受参数,但是不会有返回值

可以发现函数式接口的分类都是根据参数和返回类型进行分类,因此想要记住他们并不困难。

可能有些人比较疑惑Consumer<T>会怎么使用,此类接口用在消费对象的时候,比如发消息,更典型的比如:System.out::println

如果需要更加细分的话,还有根据参数个数进行区分。不过对于基本数据类型,上述接口都有基本数据类型的变体,主要是为了不必要的BoxUnBox操作。

一、Function

表示一个方法接收参数并返回结果。

接收单个参数

Interface Functional Method 说明
Function<T,R> R apply(T t) 接收参数类型为T,返回参数类型为R
IntFunction<R> R apply(int value) 以下三个接口,指定了接收参数类型,返回参数类型为泛型R
LongFunction<R> R apply(long value)  
Double<R> R apply(double value)  
ToIntFunction<T> int applyAsInt(T value) 以下三个接口,指定了返回参数类型,接收参数类型为泛型T
ToLongFunction<T> long applyAsLong(T value)  
ToDoubleFunction<T> double applyAsDouble(T value)  
IntToLongFunction long applyAsLong(int value) 以下六个接口,既指定了接收参数类型,也指定了返回参数类型
IntToDoubleFunction double applyAsLong(int value)  
LongToIntFunction int applyAsLong(long value)  
LongToDoubleFunction double applyAsLong(long value)  
DoubleToIntFunction int applyAsLong(double value)  
DoubleToLongFunction long applyAsLong(double value)  
UnaryOperator<T> T apply(T t) 特殊的Function,接收参数类型和返回参数类型一样
IntUnaryOperator int applyAsInt(int left, int right) 以下三个接口,制定了接收参数和返回参数类型,并且都一样
LongUnaryOperator long applyAsInt(long left, long right)  
DoubleUnaryOperator double applyAsInt(double left, double right)  

接收两个参数

interface Functional Method 说明
BiFunction<T,U,R> R apply(T t, U u) 接收两个参数的Function
ToIntBiFunction<T,U> int applyAsInt(T t, U u) 以下三个接口,指定了返回参数类型,接收参数类型分别为泛型T, U
ToLongBiFunction<T,U> long applyAsLong(T t, U u)  
ToDoubleBiFunction<T,U> double appleyAsDouble(T t, U u)  
BinaryOperator<T> T apply(T t, T u) 特殊的BiFunction, 接收参数和返回参数类型一样
IntBinaryOperator int applyAsInt(int left, int right)  
LongBinaryOperator long applyAsInt(long left, long right)  
DoubleBinaryOperator double applyAsInt(double left, double right)  

二、Consumer

表示一个方法接收参数但不产生返回值。

接收一个参数

Interface Functional Method 说明
Consumer<T> void accept(T t) 接收一个泛型参数,无返回值
IntConsumer void accept(int value) 以下三个类,接收一个指定类型的参数
LongConsumer void accept(long value)  
DoubleConsumer void accept(double value)  

接收两个参数

Interface Functional Method 说明
BiConsumer<T,U> void accept(T t, U u) 接收两个泛型参
ObjIntConsumer<T> void accept(T t, int value) 以下三个类,接收一个泛型参数,一个指定类型的参
ObjLongConsumer<T> void accept(T t, long value)  
ObjDoubleConsumer void accept(T t, double value)  

三、Supplier

返回一个结果,并不要求每次调用都返回一个新的或者独一的结果

Interface Functional Method 说明
Supplier<T> T get() 返回类型为泛型T
BooleanSupplier boolean getAsBoolean() 以下三个接口,返回指定类型
IntSupplier int getAsInt()  
LongSupplier long getAsLong()  
DoubleSupplier double getAsDouble()  

四、Predicate

根据接收参数进行断言,返回boolean类型

Interface Functional Method 说明
Predicate<T> boolean test(T t) 接收一个泛型参数
IntPredicate boolean test(int value) 以下三个接口,接收指定类型的参数
LongPredicate boolean test(long value)  
DoublePredicate boolean test(double value)  
BiPredicate<T,U> boolean test(T t, U u) 接收两个泛型参数,分别为T,U

 

 

摘自:http://dengchengchao.com/?p=1102