Java8之函数式接口

四大核心函数式接口

其他函数接口

四大核心函数式接口应用举例

Consumer接口

Consumer 接口是消费性接口，无返回值。Java8 中对 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);    }; 
	}
}

使用示例

public static void handleConsumer(Consumer<Integer> consumer,Integer number){
    consumer.accept(number);
}

@Test
public void testConsumer(){
    handleConsumer(i-> System.out.println(i),100);
}

Supplier接口

Supplier 接口是供给型接口，有返回值，Java8 中对 Supplier 接口的定义如下所示。

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

使用示例

public static List<Integer> getList(int number, Supplier<Integer> supplier){
        List<Integer> list  = new ArrayList<>();
        for (int i=0;i<number;i++){
            list.add(supplier.get());
        }
        return list;

    }

    @Test
    public void testSupplier(){
        List<Integer> list = getList(10, () -> new Random().nextInt(100));
    }

Function接口

Function 接口是函数型接口，有返回值，Java8 中对 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; 
	}
}

使用示例

public static String dealString(String str, Function<String,String> function){
    return function.apply(str);
}

@Test
public  void testFunction(){
    String str = dealString("hello",s -> s.toUpperCase());
    System.out.println(str);
}

Predicate接口

Predicate 接口是断言型接口，返回值类型为 boolean，Java8 中对 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);
	} 
}

使用说明：

public static List<String> dealPredicate(List<String> list, Predicate<String> predicate){
    List<String> stringList = new ArrayList<>();
    for (String str:list){
        if(predicate.test(str)){
            stringList.add(str);
        }
    }
    return stringList;
}

@Test
public void testPredicate(){
    System.out.println(dealPredicate(Arrays.asList("hello","world","aaa","bbb"),s->s.length()>=5));
}