java8 lambda表達式和函數型接口

/**
 * @author gc
 * Lambda  表達式的基礎語法：java8中引入一個新的操作符 "->" ,該操作符稱為箭頭操作符或lambda操作符
 *      箭頭操作符將lambda拆分成兩部分：
 *      左側：lambda表達式的參數列表
 *      右側：lambda表達式中所需執行的功能，即lambda體
 *  語法格式一：無參數，無返回值
 *      () -> System.out.println("xxxxxx");
 *  語法格式二：有一個參數，無返回值
 *      (x) -> System.out.println(xxxxxx);
 *  語法格式三：若只有一個參數，小括號可以省略不寫
 *      x -> System.out.println(x);
 *  語法格式四：有兩個以上的參數，有返回值，並且lambda體中有多條語句    test4
 *      Comparator<Integer> comparator = (x,y) -> {
 *            System.out.println("函數式接口");
 *            return Integer.compare(x, y);
 *        };
 *    語法格式五：若lambda體中只有一條語句，則return和大括號都可以省略不寫
 *        Comparator<Integer> comparator = (x,y) -> Integer.compare(x, y);
 *    語法格式六：lambda表達式的參數列表的數據類型可以省略不寫，因為jvm編譯器可以根據上下文推斷出數據類型，即“類型推斷”
 *        (Integer x,Integer y) -> Integer.compare(x, y);  == (x,y) -> Integer.compare(x, y);
 *    
 *    左右遇一括號省（左邊是一個參數或者右邊只有一條語句）， 左側推斷類型省（左邊不需要顯示指定類型）
 *
 *    二、lambda表達式需要函數式接口的支持
 *        函數式接口：接口中只有一個抽象方法的接口(這樣才知道要動態替換哪個方法)，可以使用 @FunctionalInterface 檢查一下
 *        反而言之：jdk接口上有@FunctionalInterface注解的都是函數式接口
 */
public class TestLambda {
    
    @Test
    public void test1() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Runnable r1 = () -> System.out.println("hello lambda1");
            }
        }).start();
        
        //相當於實現接口Runable無參方法run的匿名實現類.這里的實現同上面的匿名類效果一樣
        Runnable r1 = () -> System.out.println("hello lambda2");
        new Thread(r1).start();
    }
    @Test
    public void test2() {
        //這里因為是一個參數，所以左邊的括號省略，右邊是一個表達式，所以右邊的大括號省略
        //Consumer是一個消費者型的函數式接口，其accept方法可以對接收到的數據進行處理。這里相當於實現其抽象方法accept
        Consumer<String> consumer = x -> System.out.println(x);
        consumer.accept("我很帥");
    }
    
    @Test
    public void test4() {
        //這里左邊是兩個參數，所以使用括號，右邊是兩條語句，使用大括號。這里是實現了Comparator接口的compare方法，用於collection排序操作
        Comparator<Integer> comparator = (x,y) -> {
            System.out.println("函數式接口");
            return Integer.compare(x, y);
        };
        //這里是簡寫，效果同上
        Comparator<Integer> comparator2 = (x,y) -> Integer.compare(x, y);
    }
    
    //通過這里的兩個lambda實現，可以發現函數式接口的方法是動態改變的，而且不用繼續接口，不用匿名類，實現起來方便快捷
    @Test
    public void test5() {
        //(x) -> (x + 1)是一個lambda表達式，功能是自增。
        //其相當於一個入參和返回值類型相同的函數，這里將其傳給MyFun<Integer>，可以作為函數式接口MyFun內方法getValue的實現。
        //可以理解為MyFun內方法getValue的實現變成了整數值自增然后返回
        Integer result = operation(100, (x) -> (x + 1));
        //這里輸出101
        System.out.println(result);
        //這里同理，只是getValue的實現變成了自減，所以輸出結果為99
        System.out.println(operation(100, (x) -> (x - 1)));
    }
    public Integer operation(Integer num, MyFun<Integer> mf) {
        return mf.getValue(num);
    }

    List<User> users = Arrays.asList(
            new User("gc", 24, 7500),
            new User("gc", 25, 13000),
            new User("gc", 26, 20000));
    
    @Test
    public void test6() {
        //這里第二個參數是lambda表達式，其實現了函數表達式式Comparator的compare方法
        Collections.sort(users, (u1, u2) -> {
            return u1.getAge() - u2.getAge();
        });
        System.out.println(users);
    }
    @Test
    //對兩個long型進行處理
    public void test7() {
        //參數3是lambda，用於實現函數式接口。相當於MyFun2的getValue(a,b)功能變成了a+b
        op(100L, 200L, (x,y) -> x + y);
    }
    public void op(Long t1, Long t2, MyFun2<Long, Long> mf2) {
        System.out.println(mf2.getValue(t1, t2));
    }
    @Test
    public void test() {
        //這里是stream配合lambda表達式一起使用。stream這里簡單理解為遍歷list
        //(e) -> e.getSalary() >= 10000是函數式接口Predicate內方法test的實現,其功能是判斷是否正確
        //下面這里就是判斷list中的元素的salary是否大於10000，大於的繼續往下處理
        //forEach就是遍歷打印。這里總體的功能就是遍歷list，打印salary大於10000的User
        users.stream().
            filter((e) -> e.getSalary() >= 10000).forEach(System.out::println);
        users.stream().
            map((e) -> e.getName()).forEach(System.out::println);
    }
}

 

@FunctionalInterface
public interface MyFun<T> {
    
    public T getValue(T value);
}

 

@FunctionalInterface
public interface MyFun2<T, R> {
    
    public R getValue(T t1, T t2);
}

 

public class User {
    private String name;
    private int age;
    private int salary;
    private Status status;
    
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status + "]";
    }

    public User(String name, int age, int salary) {
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
}    

 

/**
 * @author gc、
 * java8 內置的四大核心函數式接口
 * 
 * Consumer<T>: 消費型接口，接收數據並處理
 *         void accept(T t);
 * Supplier<T>: 供給型接口，對外提供數據
 *         T get()
 * Function<T, R>: 函數型接口，接收參數，返回結果
 *         R apply(T t);
 * Predicate<T>: 斷言型接口，檢測入參是否符合條件（符合則返回true）
 *         boolean test(T t);
 *
 */
public class TestLambdaFunc {

    @Test
    //Consumer<T> 消費型接口
    public void testConsumer() {
        //Consumer是消費型接口，其可定義對接收到的數據進行不同的處理。這里的處理方式就是打印詳細信息。
        //m -> System.out.println("大保健，消費："+m+" 元") 可以理解為Consumer中accept(T t)方法的實現
        happy(10000L, m -> System.out.println("大保健，消費："+m+" 元"));
    }
    public void happy(double money, Consumer<Double> con) {
        con.accept(money);
    }
    
    //Supplier<T> 供給型接口
    @Test
    public void testSupplier() {
        //Supplier是供給型接口。其內部定義對外輸出的數據。而且不需要入參
        //() -> (int)(Math.random() * 100) 為這里的供給行為，即返回一個隨機數
        List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
        System.out.println(numList);
    }
    
    public List<Integer> getNumList(int num, Supplier<Integer> sup) {
        List<Integer> list = new ArrayList<>();
        
        for (int i = 0; i < num; i++) {
            Integer n = sup.get();
            list.add(n);
        }
        return list;
    }
    
    //Function<T,R> 函數型接口
    @Test
    public void testFunction() {
        //函數型接口功能相對強大，可以對接收到的數據進行進一步處理，返回類型可以和入參類型不一致（泛型接口，二元組）
        //(x) -> (x + ", 哈哈哈") 這里作為Function接口中apply的實現
        String str = strHandler("我最帥", (x) -> (x + ", 哈哈哈"));
        System.out.println(str);
    }
    private String strHandler(String str, Function<String, String> fun) {
        return fun.apply(str);
    }
    
    //Predicate<T> 斷言型接口
    @Test
    public void testPredicate() {
        List<String> list = Arrays.asList("Hello", "World", "www.exact.com");
        //函數式接口Predicate主要用於判斷，x -> (x.length() > 5) 這里是判斷入參的長度是否大於5
        List<String> filterStr = filterStr(list, x -> (x.length() > 5));
        System.out.println(filterStr);
    }
    
    public List<String> filterStr(List<String> list, Predicate<String> pre) {
        List<String> strList = new ArrayList<>();
        
        for (String str : list) {
            if(pre.test(str)) {
                strList.add(str);
            }
        }
        return strList;
    }
}

 

/**
 * @author gc
 * 方法引用：若lambda體中的內容有方法已經實現了，我們可以使用“方法引用”
 *         （可以理解為方法引用是lambda表達式的另外一種表達形式）
 * 主要有三種語法格式：
 *         對象::實例方法名
 *         類::靜態方法名
 *         類::實例方法名
 * 注意：
 *     1.lambda體中調用方法的參數列表與返回值類型，要與函數式接口中抽象方法的參數列表和返回值類型一致
 *  2.若lambda參數列表 中的第一個參數是實例方法的調用者，而第二個參數是實例方法的參數時，可以使用className::method
 *  
 *  二、構造器引用
 *  格式：
 *      ClassName::new
 */
public class TestMethodRef {

    
    //對象::實例方法名
    @Test
    public void test() {
        Consumer<String> consuemr = (x) -> System.out.println(x);
        consuemr.accept("aaaa");
        
        PrintStream ps = System.out;
        Consumer<String> consumer2 = ps::println;
        consumer2.accept("asdf");
    }
    
    @Test
    public void test2() {
        User user= new User("gc",20,200000);
        //這里是無參，所以左邊使用了()
        Supplier<String> sup = () -> user.getName();
        System.out.println(sup.get());
        
        //這里對lambda表達式進行了省略。() -> user.getAge() == user::getAge
        Supplier<Integer> sup2 = user::getAge;
        System.out.println(sup2.get());
    }
    
    //類::靜態方法名
    public void test3() {
        Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
        
        //這里因為入參和lambda實現方法要調用的入參一樣。所以兩邊都省略了
        Comparator<Integer> com1 = Integer::compare;
    }
    
    //類::實例方法名
    public void test4() {
        BiPredicate<String, String> bp = (x,y) -> x.equals(y);
        
        //這里是兩個入參，而且滿足第一個參數是新方法調用者，第二個參數是入參的情況
        //理論而言都用上面的表達式即可，看起來比較簡單，但是不能避免別人不會使用簡寫方式，看不懂豈不是很尷尬
        BiPredicate<String, String> bp2 = String::equals;
    }
    
    @Test
    public void test5() {
        //函數式接口生產數據的方式是new User();
        Supplier<User> sup = () -> new User();
        //這里功能同上，簡寫方式
        Supplier<User> sup2 = User::new;
        System.out.println(sup2.get());
    }
}