四大函数式接口

lambda表达式、链式编程、函数式接口、Stream流式计算

函数式接口：只有一个方法的接口

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
//超级多的FunctionInterface
//简化编程模型，在新版本的框架大量使用
//foreach(消费型的函数式接口)

 1.Function 

 

java.util.function

public interface Function<T,R>表示接受一个参数并产生结果的函数。
这是一个functional interface的功能方法是apply(Object) 。

R apply(T t)将此函数应用于给定的参数。  

public class FunctionDemo {

    public static void main(String[] args) {
        //匿名内部类的写法：
//        Function<String, Integer> func = new Function<String,Integer>() {
//            @Override
//            public Integer apply(String str) {
//                // TODO Auto-generated method stub
//                return Integer.valueOf(str);
//            }
//            
//        };
        //Lambda表达式
        
        Function<String, Integer> func = (str)->{return Integer.valueOf(str);};        
        System.out.println(func.apply("520"));
        
    }
}

2.Predicate 

也可以用来可以判断字符串是否为空

@FunctionalInterface
public interface Predicate<T>表示一个参数的谓词（布尔值函数）。
这是一个functional interface的功能方法是test(Object)

boolean test(T t)在给定的参数上评估这个谓词。
参数
t - 输入参数
结果
true如果输入参数匹配谓词，否则为 false

public class PredicateDemo {

    public static void main(String[] args) {
        //匿名内部类
//        Predicate<Integer> predicate = new Predicate<Integer>() {
//            @Override
//            public boolean test(Integer t) {
//                return t>20?true:false;
//            }
//            
//        };
        
        //Lambda表达式        
        Predicate<Integer> predicate = (t)->{return t>20?true:false;};
        
        System.out.println(predicate.test(20));

    }

}

3.Consumer

 

 

public interface Consumer<T>
表示接受单个输入参数并且不返回结果的操作。 与大多数其他功能界面不同， Consumer预计将通过副作用进行操作。
这是一个functional interface的功能方法是accept(Object) 。

void accept(T t)对给定的参数执行此操作。
t - 输入参数

 

 

public class ConsumerDemo {

    public static void main(String[] args) {
        //匿名内部类
//        Consumer<String> consumer = new Consumer<String>() {
//            @Override
//            public void accept(String t) {
//                System.out.println(t);                
//            }            
//        };        
        
        //Lambda表达式        
        Consumer<String> consumer = (str)->{System.out.println(str);};
        
        consumer.accept("Hello");
    }
}

 

4.Supplier

@FunctionalInterface
public interface Supplier<T>
没有要求每次调用供应商时都会返回新的或不同的结果。 这是一个functional interface的功能方法是get() 。

T get()获得结果。

public class SupplierDemo {

    public static void main(String[] args) {
//        Supplier<String> supplier = new Supplier<String>() {
//            @Override
//            public String get() {                
//                return "OK";
//            }
//            
//        };
                
        //Lambda 表达式
        Supplier<String> supplier = ()->{return "OK";};        
        System.out.println(supplier.get());
    }
}