1.常見型別及使用

import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;

/**
 * @author 
 *
 */
public
 
 class FunctionTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
//        Consumer 代表一個輸入
        Consumer<String> c2 = (a) -> {System.out.println("11打算引數：" + a);};
        Consumer<String> c3 = a -> {System.out.println("22打算引數：" + a);};
        Consumer
 
<String> c4 = (String a) -> {
            //具體的業務邏輯
            System.out.println("33打算引數：" + a);
        };
        c2.accept("這是一個入參引數啊111");  //消費
        c3.accept("這是一個入參引數啊222");  //消費
        c4.accept("這是一個入參引數啊333");  //消費
        
        //輸入2個引數，入引數據型別可以不一樣
//        BiConsumer 代表兩個輸入
        BiConsumer<String,Integer> bc =(x,y) -> {
            System.out.println(
 
"x+y"+x+y);
        };
        bc.accept("中國",100);
        
        //輸出
//        Supplier 代表一個輸出
        Supplier<String> s1 = () -> "hello";
        Supplier<String> s2 = () -> {
            //具體的業務邏輯
            return "hello22";
        };
        System.out.println("supplier1="+s1.get());
        System.out.println("supplier2="+s2.get());
        
        //輸入，輸出引數型別不同
//        Function 代表一個輸入，一個輸出（一般輸入和輸出是不同型別的） 也可以相同
        Function<String, Integer> f1 = (str) -> Integer.valueOf(str);
        Function<String, Integer> f2 = (String str) -> Integer.valueOf(str);
        Function<String, Integer> f3 = (String str) -> {
            //具體的業務邏輯
            return Integer.valueOf(str);
        };
        Function<String, String> f4 = (str) -> "hello " + str;
        
        System.out.println("f1="+f1.apply("200"));
        System.out.println("f2="+f2.apply("300"));
        System.out.println("f3="+f3.apply("400"));
        System.out.println("f4="+f4.apply("中國"));
        
        //輸入輸出引數相同
        //unary一元操作
//        UnaryOperator 代表一個輸入，一個輸出（輸入和輸出是相同型別的）
        UnaryOperator<String> u1 = (str) -> "hello"+str;
        System.out.println("u1="+u1.apply("chinese"));
        
        //BiFunction 代表兩個輸入，一個輸出（一般輸入和輸出是不同型別的）
        BiFunction<String,String,Integer> bf = (x,y) -> x.length()+y.length();
        int length = bf.apply("abc","def");
        System.out.println("字串長度="+length);
        
        //BinaryOperator 代表兩個輸入，一個輸出（輸入和輸出是相同型別的）
        //二元操作
        BinaryOperator<String> bo = (x,y) -> x+y;
        String str = bo.apply("中國", "上海");
        System.out.println(str);
        
        
    }

}

2.固定型別及使用

import java.util.function.BiPredicate;
import java.util.function.BooleanSupplier;
import java.util.function.DoubleBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.LongFunction;
import java.util.function.Predicate;

/**
 * @author 
 *
 */
public class Function2Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //判斷返回boolean
        BiPredicate<Integer, Integer> bp = (x,y) -> {return x+y == 100;};
        System.out.println(bp.test(20, 80));
        System.out.println(bp.test(20, 81));
        
        //輸出 布林值
        BooleanSupplier bs = () -> true;
        BooleanSupplier bs2 = () -> false;
        System.out.println(bs.getAsBoolean());
        System.out.println(bs2.getAsBoolean());
        
        //固定型別
        DoubleBinaryOperator dbo = (x,y) -> x+y;
        System.out.println(dbo.applyAsDouble(1.0, 2.0));
        
        //固定型別
        IntConsumer ic = (x) -> {System.out.println(x+ 100);};
        ic.accept(500);
        
        //固定型別
        LongFunction<String> lf = (x) -> String.valueOf(x);
        System.out.println(lf.apply(1000l));

        Predicate<Integer> p = (x) -> {return x == 100;};
        System.out.println(p.test(100));
        System.out.println(p.test(200));
        
    }

}