四大函数式接口

四大函数式接口Function/predicate/Supplier/Consumer

• Supplier 供给型接口，没有输入参数，只有返回值
• predicate 断定性接口：有一个输入参数，返回布尔值
• Consumer 消费型接口：只有输入，没有返回值
• Function 函数型接口，只有一个参数，有一个输出

Supplier 供给型接口，没有输入参数，只有返回值

package Function;

import java.util.function.Supplier;

/**Supplier 供给型接口，没有输入参数，只有返回值
 * @author liu
 */
public class SupplierA {
   public static void main(String[] args) {
/*        Supplier supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 2222;
            }
        };*/
       Supplier<Integer> supplier =()->{return 2222;};
       System.out.println(supplier.get());
    }
}

predicate 断定性接口：有一个输入参数，返回布尔值

package Function;

import java.util.function.Predicate;

/**predicate 断定性接口：有一个输入参数，返回布尔值
 * @author liu
 */
public class PredicateA {
    public static void main(String[] args) {
        //判断字符串是否为空
/*        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.isEmpty();
            }
        };*/
        Predicate<String> predicate =(s)->{return s.isEmpty();};
                System.out.println(predicate.test("1"));
    }
}

Consumer 消费型接口：只有输入，没有返回值

package Function;

import java.util.function.Consumer;

/**Consumer 消费型接口：只有输入，没有返回值
 * @author liu
 */
public class ConsumerA {
    public static void main(String[] args) {
/*        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };*/
        Consumer<String> consumer =(s)->{System.out.println(s);};
        consumer.accept("2");
    }
}

Function 函数型接口，只有一个参数，有一个输出

package Function;

import java.util.function.Function;

/**Function 函数型接口，只有一个参数，有一个输出
 * 只要是函数型接口，就可以用lambda简化
 * @author liu
 */
public class FunctionA {
    public static void main(String[] args) {
/*        Function<Integer, Integer> function = new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer o) {
                return o;
            }
        };*/
Function<Integer,Integer> function=(o)->{return o;};
        System.out.println(function.apply(7));
    }
}