Java中Util下Function接口简介说明

java中函数式接口在Lambda中经常使用,那么Java8中有哪些常见的函数式接口呢?
下文笔者将一一道来,如下所示

JDk8中常见的函数式接口:
    Consumer、Supplier、Predicate和Function
	其具体功能,如下所示

Consumer接口

Consumer 接口就是一个消费型的接口
我们传入参数,不返回任何信息

Consumer接口源码

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

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

例:Stream中foreach方法
要求传的参数为Consumer

void forEach(Consumer<? super T> action);

Consumer示例

 
/**
     * consumer接口测试
     */
@Test
public void test_Consumer() {
    //① 使用consumer接口实现方法
    Consumer<String> consumer = new Consumer<String>() {

        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    Stream<String> stream = Stream.of("java265.com-1", "java265.com-2", "java265.com-3", "java265.com-4", "java265.com-5");
    stream.forEach(consumer);

    System.out.println("********************");

    //② 使用lambda表达式，forEach方法需要的就是一个Consumer接口
    stream = Stream.of("java265.com-1", "java265.com-2", "java265.com-3", "java265.com-4", "java265.com-5");
    Consumer<String> consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口
    stream.forEach(consumer1);
    //更直接的方式
    //stream.forEach((s) -> System.out.println(s));
    System.out.println("********************");

    //③ 使用方法引用，方法引用也是一个consumer
    stream = Stream.of("java265.com-1", "java265.com-2", "java265.com-3", "java265.com-4", "java265.com-5");
    Consumer consumer2 = System.out::println;
    stream.forEach(consumer);
    //更直接的方式
    //stream.forEach(System.out::println);
}

consumer接口核心原理分析

 
 Consumer接口中有一个名为accept的方法
 这个方法传入一个参数,但是没有返回值
  直接对传入参数进行处理
   这就是Consumer接口的核心功能---只处理参数，无返回值 
 

lambda表达式consumer

Consumer<String> consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口

方法引用consumer

Consumer consumer2 = System.out::println;
  使用一个方法引用的方式作为一个 Consumer
   然后将方法传给forEach

Predicate接口

Predicate接口是一个判断型接口
    它对输入参数进行判断,并返回bool型信息

Predicate源码

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

	//以下用的比较少，待研究...
	default Predicate<T> and(Predicate<? super T> other) {
		Objects.requireNonNull(other);
		return (t) -> test(t) && other.test(t);
	}

	default Predicate<T> negate() {
		return (t) -> !test(t);
	}

	default Predicate<T> or(Predicate<? super T> other) {
		Objects.requireNonNull(other);
		return (t) -> test(t) || other.test(t);
	}

	static <T> Predicate<T> isEqual(Object targetRef) {
		return (null == targetRef)
				? Objects::isNull
				: object -> targetRef.equals(object);
	}
}

Stream中filter方法采用的Predicate

Stream<T> filter(Predicate<? super T> predicate);

Predicate示例

@Test
public void test_Predicate2() {
    //① 将Predicate作为filter接口，Predicate起到一个判断的作用
    Predicate<Integer> predicate = new Predicate<Integer>() {
        @Override
        public boolean test(Integer integer) {
            if(integer > 10){
                return true;
            }
            return false;
        }
    };

    Stream<Integer> stream = Stream.of(22,56,23,98,110,230);
    list<Integer> list = stream.filter(predicate).collect(Collectors.toList());
    list.forEach(System.out::println);

    System.out.println("********************");

}

Predicate是一个谓词型接口
   只起到一个判断作用

Predicate通过实现一个test方法做判断

Function接口

Fuction接口是一个功能型接口
   它主要起转换作用
   将数据转换为另一种形式输出

Function接口源码

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);
    
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

例:
Stream中map方法

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

Function接口示例

 
@Test
public void test_Function() {
    //① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型
    Function<String, Integer> function = new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            return s.length();//获取每个字符串的长度，并且返回
        }
    };

    Stream<String> stream = Stream.of("java265.com-1", "java265.com-2", "java我最爱的网站");
    Stream<Integer> stream1 = stream.map(function);
    stream1.forEach(System.out::println);
}

Function接口功能

 1.Function接口是一个功能型接口
     起数据转换的作用

 2.Function接口实现apply方法来做转换 

Supplier

Supplier接口就是一个供给型 的接口
   就是一个容器。

Supplier源码

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}
 

Supplier示例

 
**
* Supplier接口测试，supplier相当一个容器或者变量，可以存储值
*/
@Test
public void test_Supplier() {
//使用Supplier接口实现方法,只有一个get方法，无参数，返回一个值
Supplier<Integer> supplier = new Supplier<Integer>() {
	@Override
	public Integer get() {
		//返回一个随机值
		return new Random().nextInt();
	}
};

System.out.println(supplier.get());

System.out.println("********************");

//使用lambda表达式，
Supplier supplier = () -> new Random().nextInt();
System.out.println(supplier.get());
System.out.println("********************");

//使用方法引用
Supplier<Double> supplier2 = Math::random;
System.out.println(supplier2.get());
}

名称	类型	备注
Consumer	Consumer<T>	接收T对象，不返回值
Predicate	Predicate<T>	接收T对象并返回 boolean
Function	Function<T,R>	接收T对象，返回R对象
Supplier	Supplier<T>	提供对象，不接收值

来顶一下

返回首页