lambda入門&函數式接口（一）

java8新特性大綱

lambda表達式入門

package com.baidu;

import java.util.function.Consumer;

/**
 * lambda表達式的使用：
 * 1.舉例: Comparator<Interger> c = (o1,o2) -> Integer.compare(o1,o2);
 * 2.格式
 *      -> ：lambda操作符 或 箭頭操作符
 *      ->左邊: lambda參數列表(其實就是抽象方法的參數列表)
 *      ->右邊: lambda體 (其實就是重寫抽象方法的方法體)
 *
 * 3.lambda表達式分爲6種情況介紹: 都是針對抽象方法來說的！
 *    0/1/多個參數 和 有/無返回值進行一個組合就有六種情況！
 *    1.無參，無返回值
 *    2.無參，有返回值
 *    3.有一個參數，無返回值
 *    4.有一個參數，有返回值
 *    5.有多個參數，無返回值
 *    6.有多個參數，有返回值
 *
 * 4.在java中lambda表達式的本質：就是作爲函數式接口的實例！
 *
 * 5.可能你感覺這個lambda表達式不就是創建匿名內部類的嗎有必要學這麼多嗎
 *   到了後面的Stream流的方法的參數類型，基本上都是函數式接口了!,使用Stream流
 *   對集合操作跟操作表差不多！
 *
 *
 * 6.類型推斷:
 *   List<Integer> list = new ArrayList<Integer>();
 *   因爲有類型推斷所以也可以寫成如下:
 *   List<Integer> list = new ArrayList<>();
 *
 *   int[] arr = new int[]{1,2,3};
 *   因爲有類型推斷所以也可以寫成如下:
 *   int[] arr = {1,2,3};
 *
 * 7.@FunctionalInterface: 它就是可以校驗一下你是不是函數式接口！，跟@Override本質一樣
 *   
 * 8.函數式接口：接口中只有一個抽象方法：比如Runnable,Comparator不是Comparable
 *
 * 9.總結
 *   注：以前用匿名實現類來表示的，現在都可以用lambda表達式來實現!
 *   注：在lambda表達式中，如果方法體中的語句只有一句那麼{}可以省了,
 *       一旦{}省了，如果該方法有返回值，則return必須省了，
 *       但如果方法體中的語句只有一句,如果加了{}, return是根據方法的返回值決定加不加！
 *   注：遇見 :: 就是方法引用，遇見 -> 就是lambda表達式！
 */
public class LambdaTest {

    public static void main(String[] args) {
        noParameterAndNoReturn();
        singleParameterAndNoReturn();
    }

    //單參，無返回值
    private static void singleParameterAndNoReturn() {
        //第一種寫法
        Consumer<String> c = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        c.accept("hello world");

        //第二種寫法：使用lambda表達式之後
        Consumer<String> c2 = (String s) -> {
            System.out.println(s);
        };
        c2.accept("雖然帥，但是菜");

        //第三種寫法：在上面精簡一下
        /**
         * 1.這裏省了不寫參數的類型，是因爲類型推斷, 編譯器可以推斷的出來！ 就像泛型和數組中一樣
         * 2.這裏省了不寫{}, 是因爲當只有一條語句的話，就可以省了{},如果該方法有返回值的話，還可以省了return：前提是隻有一條語句！！！
         * 3.若只有一個參數，此時參數的小括號也可以省了
         */
        Consumer<String> c3 = (s) ->  System.out.println(s);
        c3.accept("wzj");


        Consumer<String> c4 = s ->  System.out.println(s);
        c3.accept("nb");

    }

    // 無參，無返回值
    private static void noParameterAndNoReturn() {
        Runnable r =  new Runnable() {
            @Override
            public void run() {
                System.out.println("run().....");
            }
        };
        r.run();

        // 使用lambda表達式之後
        Runnable r2 = () -> {
            System.out.println("run2().....");
        };

        r2.run();
    }
}

四大核心函數式接口！

package cn.itcast.lambda;


import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * java內置的4大核心函數式接口！
 * 消費型接口: Consumer<T> void accpet(T t)
 * 供給型接口: supplier<T> T get()
 * 函數型接口 Function<T,R> R apply(T t)
 * 斷定型接口: Predicate<T> boolean test(T t)
 */
public class LambdaTest2 {

    @Test
    public  void test1(){
        testConsumer(20, new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println("我買了根辣條,消費了"+integer);
            }
        });

        //使用lambda表達式: 因爲參數只有一個參數，所以可以省了(), 因爲只有一條語句所以可以省了{}
        testConsumer(30,integer ->  System.out.println("我買了根辣條,消費了"+integer));
    }

    private static void testConsumer(int money, Consumer<Integer> consumer) {
        consumer.accept(money);
    }

    @Test
    public void test2(){
        List<String> list = new ArrayList<>(Arrays.asList("春天","夏天","秋天","冬天"));
        //一：使用匿名內部類的方式
        List<String> filterList = testPredicate(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("春");
            }
        });
        System.out.println(filterList);

        //二：使用lambda表達式
        List<String> filterList2 = testPredicate(list,s -> s.contains("春"));
        System.out.println(filterList2);
    }

    // 根據給定的規則，過濾集合中的字符串, 此規則由Predicate的抽象方法決定！
    private static List<String> testPredicate(List<String> list, Predicate<String> filterCondition) {
       List<String> filterList = new ArrayList<>();
       for (String s:list) {
          if (filterCondition.test(s)) {
              filterList.add(s);
          }
       }
        return filterList;
    }
    
}

來自：雖然帥，但是菜的cxy，每天進步一點點！！