Lambda表達式學習

函數式接口

/*
    函數式接口的使用:一般可以作爲方法的參數和返回值類型
 */
public class Demo {
    //定義一個方法,參數使用函數式接口MyFunctionalInterface
    public static void show(MyFunctionalInterface myInter){
        myInter.method();
    }

    public static void main(String[] args) {
        //調用show方法,方法的參數是一個接口,所以可以傳遞接口的實現類對象
        show(new MyFunctionalInterfaceImpl());

        //調用show方法,方法的參數是一個接口,所以我們可以傳遞接口的匿名內部類
        show(new MyFunctionalInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名內部類重寫接口中的抽象方法");
            }
        });

        //調用show方法,方法的參數是一個函數式接口,所以我們可以Lambda表達式
        show(()->{
            System.out.println("使用Lambda表達式重寫接口中的抽象方法");
        });

        //簡化Lambda表達式
        show(()-> System.out.println("使用Lambda表達式重寫接口中的抽象方法"));
    }
}

/*
    函數式接口:有且只有一個抽象方法的接口,稱之爲函數式接口
    當然接口中可以包含其他的方法(默認,靜態,私有)

    @FunctionalInterface註解
    作用:可以檢測接口是否是一個函數式接口
        是:編譯成功
        否:編譯失敗(接口中沒有抽象方法抽象方法的個數多餘1個)
 */
@FunctionalInterface
public interface MyFunctionalInterface {
    //定義一個抽象方法
    public abstract void method();
}

/*
    @Override註解
    檢查方法是否爲重寫的方法
        是:編譯成功
        否:編譯失敗
 */
public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{
    @Override
    public void method() {

    }

    /*@Override
    public void method2() {

    }*/

    /*@Override
    public void method3() {

    }*/
}

showLog

/*
    日誌案例

    發現以下代碼存在的一些性能浪費的問題
    調用showLog方法,傳遞的第二個參數是一個拼接後的字符串
    先把字符串拼接好,然後在調用showLog方法
    showLog方法中如果傳遞的日誌等級不是1級
    那麼就不會是如此拼接後的字符串
    所以感覺字符串就白拼接了,存在了浪費
 */
public class Demo01Logger {
    //定義一個根據日誌的級別,顯示日誌信息的方法
    public static void showLog(int level, String message){
        //對日誌的等級進行判斷,如果是1級別,那麼輸出日誌信息
        if(level==1){
            System.out.println(message);
        }
    }

    public static void main(String[] args) {
        //定義三個日誌信息
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        //調用showLog方法,傳遞日誌級別和日誌信息
        showLog(2,msg1+msg2+msg3);

    }
}
/*
    使用Lambda優化日誌案例
    Lambda的特點:延遲加載
    Lambda的使用前提,必須存在函數式接口
 */
public class Demo02Lambda {
    //定義一個顯示日誌的方法,方法的參數傳遞日誌的等級和MessageBuilder接口
    public static void showLog(int level, MessageBuilder mb){
        //對日誌的等級進行判斷,如果是1級,則調用MessageBuilder接口中的builderMessage方法
        if(level==1){
            System.out.println(mb.builderMessage());
        }
    }

    public static void main(String[] args) {
        //定義三個日誌信息
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        //調用showLog方法,參數MessageBuilder是一個函數式接口,所以可以傳遞Lambda表達式
        /*showLog(2,()->{
            //返回一個拼接好的字符串
            return  msg1+msg2+msg3;
        });*/

        /*
            使用Lambda表達式作爲參數傳遞,僅僅是把參數傳遞到showLog方法中
            只有滿足條件,日誌的等級是1級
                纔會調用接口MessageBuilder中的方法builderMessage
                纔會進行字符串的拼接
            如果條件不滿足,日誌的等級不是1級
                那麼MessageBuilder接口中的方法builderMessage也不會執行
                所以拼接字符串的代碼也不會執行
            所以不會存在性能的浪費
         */
        showLog(1,()->{
            System.out.println("不滿足條件不執行");
            //返回一個拼接好的字符串
            return  msg1+msg2+msg3;
        });
    }
}

@FunctionalInterface
public interface MessageBuilder {
    //定義一個拼接消息的抽象方法,返回被拼接的消息
    public abstract String builderMessage();
}

Lambda進行傳參

/*
    例如java.lang.Runnable接口就是一個函數式接口，
    假設有一個startThread方法使用該接口作爲參數，那麼就可以使用Lambda進行傳參。
    這種情況其實和Thread類的構造方法參數爲Runnable沒有本質區別。
 */
public class Demo01Runnable {
    //定義一個方法startThread,方法的參數使用函數式接口Runnable
    public static void startThread(Runnable run){
        //開啓多線程
        new Thread(run).start();
    }

    public static void main(String[] args) {
        //調用startThread方法,方法的參數是一個接口,那麼我們可以傳遞這個接口的匿名內部類
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"-->"+"線程啓動了");
            }
        });

        //調用startThread方法,方法的參數是一個函數式接口,所以可以傳遞Lambda表達式
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"-->"+"線程啓動了");
        });

        //優化Lambda表達式
        startThread(()->System.out.println(Thread.currentThread().getName()+"-->"+"線程啓動了"));
    }
}

import java.util.Arrays;
import java.util.Comparator;

/*
    如果一個方法的返回值類型是一個函數式接口，那麼就可以直接返回一個Lambda表達式。
    當需要通過一個方法來獲取一個java.util.Comparator接口類型的對象作爲排序器時,就可以調該方法獲取。
 */
public class Demo02Comparator {
    //定義一個方法,方法的返回值類型使用函數式接口Comparator
    public static Comparator<String> getComparator(){
        //方法的返回值類型是一個接口,那麼我們可以返回這個接口的匿名內部類
        /*return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串的降序排序
                return o2.length()-o1.length();
            }
        };*/

        //方法的返回值類型是一個函數式接口,所有我們可以返回一個Lambda表達式
        /*return (String o1, String o2)->{
            //按照字符串的降序排序
            return o2.length()-o1.length();
        };*/

        //繼續優化Lambda表達式
        return (o1, o2)->o2.length()-o1.length();
    }

    public static void main(String[] args) {
        //創建一個字符串數組
        String[] arr = {"aaa","b","cccccc","dddddddddddd"};
        //輸出排序前的數組
        System.out.println(Arrays.toString(arr));//[aaa, b, cccccc, dddddddddddd]
        //調用Arrays中的sort方法,對字符串數組進行排序
        Arrays.sort(arr,getComparator());
        //輸出排序後的數組
        System.out.println(Arrays.toString(arr));//[dddddddddddd, cccccc, aaa, b]
    }

}

Supplier接口編程

import java.util.function.Supplier;

/*
    常用的函數式接口
    java.util.function.Supplier<T>接口僅包含一個無參的方法：T get()。用來獲取一個泛型參數指定類型的對象數據。

    Supplier<T>接口被稱之爲生產型接口,指定接口的泛型是什麼類型,那麼接口中的get方法就會生產什麼類型的數據
 */
public class Demo01Supplier {
    //定義一個方法,方法的參數傳遞Supplier<T>接口,泛型執行String,get方法就會返回一個String
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        //調用getString方法,方法的參數Supplier是一個函數式接口,所以可以傳遞Lambda表達式
        String s = getString(()->{
            //生產一個字符串,並返回
            return "胡歌";
        });
        System.out.println(s);

        //優化Lambda表達式
        String s2 = getString(()->"胡歌");
        System.out.println(s2);
    }
}

/*
    練習：求數組元素最大值
        使用Supplier接口作爲方法參數類型，通過Lambda表達式求出int數組中的最大值。
        提示：接口的泛型請使用java.lang.Integer類。
 */
public class Demo02Test {
   //定義一個方法,用於獲取int類型數組中元素的最大值,方法的參數傳遞Supplier接口,泛型使用Integer
   public static int getMax(Supplier<Integer> sup){
       return sup.get();
   }

    public static void main(String[] args) {
        //定義一個int類型的數組,並賦值
        int[] arr = {100,0,-50,880,99,33,-30};
        //調用getMax方法,方法的參數Supplier是一個函數式接口,所以可以傳遞Lambda表達式
        int maxValue = getMax(()->{
            //獲取數組的最大值,並返回
            //定義一個變量,把數組中的第一個元素賦值給該變量,記錄數組中元素的最大值
            int max = arr[0];
            //遍歷數組,獲取數組中的其他元素
            for (int i : arr) {
                //使用其他的元素和最大值比較
                if(i>max){
                    //如果i大於max,則替換max作爲最大值
                    max = i;
                }
            }
            //返回最大值
            return max;
        });
        System.out.println("數組中元素的最大值是:"+maxValue);
    }
}

Consumer編程

/*
    java.util.function.Consumer<T>接口則正好與Supplier接口相反，
        它不是生產一個數據，而是消費一個數據，其數據類型由泛型決定。
    Consumer接口中包含抽象方法void accept(T t)，意爲消費一個指定泛型的數據。

   Consumer接口是一個消費型接口,泛型執行什麼類型,就可以使用accept方法消費什麼類型的數據
   至於具體怎麼消費(使用),需要自定義(輸出,計算....)
 */
public class Demo01Consumer {
    /*
        定義一個方法
        方法的參數傳遞一個字符串的姓名
        方法的參數傳遞Consumer接口,泛型使用String
        可以使用Consumer接口消費字符串的姓名
     */
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

    public static void main(String[] args) {
        //調用method方法,傳遞字符串姓名,方法的另一個參數是Consumer接口,是一個函數式接口,所以可以傳遞Lambda表達式
        method("趙麗穎",(String name)->{
            //對傳遞的字符串進行消費
            //消費方式:直接輸出字符串
            //System.out.println(name);

            //消費方式:把字符串進行反轉輸出
            String reName = new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

import java.util.function.Consumer;

/*
   Consumer接口的默認方法andThen
   作用:需要兩個Consumer接口,可以把兩個Consumer接口組合到一起,在對數據進行消費

   例如:
    Consumer<String> con1
    Consumer<String> con2
    String s = "hello";
    con1.accept(s);
    con2.accept(s);
    連接兩個Consumer接口  再進行消費
    con1.andThen(con2).accept(s); 誰寫前邊誰先消費
*/
public class Demo02AndThen {
    //定義一個方法,方法的參數傳遞一個字符串和兩個Consumer接口,Consumer接口的泛型使用字符串
    public static void method(String s, Consumer<String> con1 ,Consumer<String> con2){
        //con1.accept(s);
        //con2.accept(s);
        //使用andThen方法,把兩個Consumer接口連接到一起,在消費數據
        con1.andThen(con2).accept(s);//con1連接con2,先執行con1消費數據,在執行con2消費數據
    }

    public static void main(String[] args) {
        //調用method方法,傳遞一個字符串,兩個Lambda表達式
        method("Hello",
                (t)->{
                    //消費方式:把字符串轉換爲大寫輸出
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    //消費方式:把字符串轉換爲小寫輸出
                    System.out.println(t.toLowerCase());
                });
    }
}

import java.util.function.Consumer;

/*
    練習:
        字符串數組當中存有多條信息，請按照格式“姓名：XX。性別：XX。”的格式將信息打印出來。
        要求將打印姓名的動作作爲第一個Consumer接口的Lambda實例，
        將打印性別的動作作爲第二個Consumer接口的Lambda實例，
        將兩個Consumer接口按照順序“拼接”到一起。
 */
public class Demo03Test {
    //定義一個方法,參數傳遞String類型的數組和兩個Consumer接口,泛型使用String
    public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){
        //遍歷字符串數組
        for (String message : arr) {
            //使用andThen方法連接兩個Consumer接口,消費字符串
            con1.andThen(con2).accept(message);
        }
    }

    public static void main(String[] args) {
        //定義一個字符串類型的數組
        String[] arr = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男" };

        //調用printInfo方法,傳遞一個字符串數組,和兩個Lambda表達式
        printInfo(arr,(message)->{
            //消費方式:對message進行切割,獲取姓名,按照指定的格式輸出
            String name = message.split(",")[0];
            System.out.print("姓名: "+name);
        },(message)->{
            //消費方式:對message進行切割,獲取年齡,按照指定的格式輸出
            String age = message.split(",")[1];
            System.out.println("。年齡: "+age+"。");
        });

    }

}

Predicate接口

import java.util.function.Predicate;

/*
    java.util.function.Predicate<T>接口
    作用:對某種數據類型的數據進行判斷,結果返回一個boolean值

    Predicate接口中包含一個抽象方法：
        boolean test(T t):用來對指定數據類型數據進行判斷的方法
            結果:
                符合條件,返回true
                不符合條件,返回false
*/
public class Demo01Predicate {
    /*
        定義一個方法
        參數傳遞一個String類型的字符串
        傳遞一個Predicate接口,泛型使用String
        使用Predicate中的方法test對字符串進行判斷,並把判斷的結果返回
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return  pre.test(s);
    }

    public static void main(String[] args) {
        //定義一個字符串
        String s = "abcdef";

        //調用checkString方法對字符串進行校驗,參數傳遞字符串和Lambda表達式
        /*boolean b = checkString(s,(String str)->{
            //對參數傳遞的字符串進行判斷,判斷字符串的長度是否大於5,並把判斷的結果返回
            return str.length()>5;
        });*/

        //優化Lambda表達式
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);
    }
}

import java.util.function.Predicate;

/*
    邏輯表達式:可以連接多個判斷的條件
    &&:與運算符,有false則false
    ||:或運算符,有true則true
    !:非(取反)運算符,非真則假,非假則真

    需求:判斷一個字符串,有兩個判斷的條件
        1.判斷字符串的長度是否大於5
        2.判斷字符串中是否包含a
    兩個條件必須同時滿足,我們就可以使用&&運算符連接兩個條件

    Predicate接口中有一個方法and,表示並且關係,也可以用於連接兩個判斷條件
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> this.test(t) && other.test(t);
    }
    方法內部的兩個判斷條件,也是使用&&運算符連接起來的
 */
public class Demo02Predicate_and {
    /*
        定義一個方法,方法的參數,傳遞一個字符串
        傳遞兩個Predicate接口
            一個用於判斷字符串的長度是否大於5
            一個用於判斷字符串中是否包含a
            兩個條件必須同時滿足
     */
    public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        //return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);//等價於return pre1.test(s) && pre2.test(s);
    }

    public static void main(String[] args) {
        //定義一個字符串
        String s = "abcdef";
        //調用checkString方法,參數傳遞字符串和兩個Lambda表達式
        boolean b = checkString(s,(String str)->{
            //判斷字符串的長度是否大於5
            return str.length()>5;
        },(String str)->{
            //判斷字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}

import java.util.function.Predicate;

/*
     需求:判斷一個字符串,有兩個判斷的條件
        1.判斷字符串的長度是否大於5
        2.判斷字符串中是否包含a
    滿足一個條件即可,我們就可以使用||運算符連接兩個條件

    Predicate接口中有一個方法or,表示或者關係,也可以用於連接兩個判斷條件
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    方法內部的兩個判斷條件,也是使用||運算符連接起來的
 */
public class Demo03Predicate_or {
    /*
            定義一個方法,方法的參數,傳遞一個字符串
            傳遞兩個Predicate接口
                一個用於判斷字符串的長度是否大於5
                一個用於判斷字符串中是否包含a
                滿足一個條件即可
         */
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
        //return pre1.test(s) || pre2.test(s);
        return  pre1.or(pre2).test(s);//等價於return pre1.test(s) || pre2.test(s);
    }

    public static void main(String[] args) {
        //定義一個字符串
        String s = "bc";
        //調用checkString方法,參數傳遞字符串和兩個Lambda表達式
        boolean b = checkString(s,(String str)->{
            //判斷字符串的長度是否大於5
            return str.length()>5;
        },(String str)->{
            //判斷字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}

import java.util.function.Predicate;

/*
    需求:判斷一個字符串長度是否大於5
        如果字符串的長度大於5,那返回false
        如果字符串的長度不大於5,那麼返回true
    所以我們可以使用取反符號!對判斷的結果進行取反

    Predicate接口中有一個方法negate,也表示取反的意思
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
 */
public class Demo04Predicate_negate {
    /*
           定義一個方法,方法的參數,傳遞一個字符串
           使用Predicate接口判斷字符串的長度是否大於5
    */
    public static boolean checkString(String s, Predicate<String> pre){
        //return !pre.test(s);
        return  pre.negate().test(s);//等效於return !pre.test(s);
    }

    public static void main(String[] args) {
        //定義一個字符串
        String s = "abc";
        //調用checkString方法,參數傳遞字符串和Lambda表達式
        boolean b = checkString(s,(String str)->{
            //判斷字符串的長度是否大於5,並返回結果
            return str.length()>5;
        });
        System.out.println(b);
    }
}

import java.util.ArrayList;
import java.util.function.Predicate;

/*
    練習：集合信息篩選
    數組當中有多條“姓名+性別”的信息如下，
    String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男", "趙麗穎,女" };
    請通過Predicate接口的拼裝將符合要求的字符串篩選到集合ArrayList中，
    需要同時滿足兩個條件：
        1. 必須爲女生；
        2. 姓名爲4個字。

    分析:
        1.有兩個判斷條件,所以需要使用兩個Predicate接口,對條件進行判斷
        2.必須同時滿足兩個條件,所以可以使用and方法連接兩個判斷條件
 */
public class Demo05Test {
    /*
        定義一個方法
        方法的參數傳遞一個包含人員信息的數組
        傳遞兩個Predicate接口,用於對數組中的信息進行過濾
        把滿足條件的信息存到ArrayList集合中並返回
     */
    public static ArrayList<String> filter(String[] arr,Predicate<String> pre1,Predicate<String> pre2){
        //定義一個ArrayList集合,存儲過濾之後的信息
        ArrayList<String> list = new ArrayList<>();
        //遍歷數組,獲取數組中的每一條信息
        for (String s : arr) {
            //使用Predicate接口中的方法test對獲取到的字符串進行判斷
            boolean b = pre1.and(pre2).test(s);
            //對得到的布爾值進行判斷
            if(b){
                //條件成立,兩個條件都滿足,把信息存儲到ArrayList集合中
                list.add(s);
            }
        }
        //把集合返回
        return list;
    }

    public static void main(String[] args) {
        //定義一個儲存字符串的數組
        String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男", "趙麗穎,女" };
        //調用filter方法,傳遞字符串數組和兩個Lambda表達式
        ArrayList<String> list = filter(array,(String s)->{
            //獲取字符串中的性別,判斷是否爲女
           return s.split(",")[1].equals("女");
        },(String s)->{
            //獲取字符串中的姓名,判斷長度是否爲4個字符
           return s.split(",")[0].length()==4;
        });
        //遍歷集合
        for (String s : list) {
            System.out.println(s);
        }
    }
}

import java.util.function.Function;

/*
    java.util.function.Function<T,R>接口用來根據一個類型的數據得到另一個類型的數據，
        前者稱爲前置條件，後者稱爲後置條件。
    Function接口中最主要的抽象方法爲：R apply(T t)，根據類型T的參數獲取類型R的結果。
        使用的場景例如：將String類型轉換爲Integer類型。
 */
public class Demo01Function {
    /*
        定義一個方法
        方法的參數傳遞一個字符串類型的整數
        方法的參數傳遞一個Function接口,泛型使用<String,Integer>
        使用Function接口中的方法apply,把字符串類型的整數,轉換爲Integer類型的整數
     */
    public static void change(String s, Function<String,Integer> fun){
        //Integer in = fun.apply(s);
        int in = fun.apply(s);//自動拆箱 Integer->int
        System.out.println(in);
    }

    public static void main(String[] args) {
        //定義一個字符串類型的整數
        String s = "1234";
        //調用change方法,傳遞字符串類型的整數,和Lambda表達式
        change(s,(String str)->{
            //把字符串類型的整數,轉換爲Integer類型的整數返回
            return Integer.parseInt(str);
        });
        //優化Lambda
        change(s,str->Integer.parseInt(str));
    }
}

import java.util.function.Function;

/*
    Function接口中的默認方法andThen:用來進行組合操作

    需求:
        把String類型的"123",轉換爲Inteter類型,把轉換後的結果加10
        把增加之後的Integer類型的數據,轉換爲String類型

    分析:
        轉換了兩次
        第一次是把String類型轉換爲了Integer類型
            所以我們可以使用Function<String,Integer> fun1
                Integer i = fun1.apply("123")+10;
        第二次是把Integer類型轉換爲String類型
            所以我們可以使用Function<Integer,String> fun2
                String s = fun2.apply(i);
        我們可以使用andThen方法,把兩次轉換組合在一起使用
            String s = fun1.andThen(fun2).apply("123");
            fun1先調用apply方法,把字符串轉換爲Integer
            fun2再調用apply方法,把Integer轉換爲字符串
 */
public class Demo02Function_andThen {
    /*
        定義一個方法
        參數串一個字符串類型的整數
        參數再傳遞兩個Function接口
            一個泛型使用Function<String,Integer>
            一個泛型使用Function<Integer,String>
     */
    public static void change(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }

    public static void main(String[] args) {
        //定義一個字符串類型的整數
        String s = "123";
        //調用change方法,傳遞字符串和兩個Lambda表達式
        change(s,(String str)->{
            //把字符串轉換爲整數+10
            return Integer.parseInt(str)+10;
        },(Integer i)->{
            //把整數轉換爲字符串
            return i+"";
        });

        //優化Lambda表達式
        change(s,str->Integer.parseInt(str)+10,i->i+"");
    }
}

import java.util.function.Function;

/*
    練習：自定義函數模型拼接
    題目
    請使用Function進行函數模型的拼接，按照順序需要執行的多個函數操作爲：
        String str = "趙麗穎,20";

    分析:
    1. 將字符串截取數字年齡部分，得到字符串；
        Function<String,String> "趙麗穎,20"->"20"
    2. 將上一步的字符串轉換成爲int類型的數字；
        Function<String,Integer> "20"->20
    3. 將上一步的int數字累加100，得到結果int數字。
        Function<Integer,Integer> 20->120
 */
public class Demo03Test {
    /*
        定義一個方法
        參數傳遞包含姓名和年齡的字符串
        參數再傳遞3個Function接口用於類型轉換
     */
    public static int change(String s, Function<String,String> fun1,
                             Function<String,Integer> fun2,Function<Integer,Integer> fun3){
        //使用andThen方法把三個轉換組合到一起
        return fun1.andThen(fun2).andThen(fun3).apply(s);
    }

    public static void main(String[] args) {
        //定義一個字符串
        String str = "趙麗穎,20";
        //調用change方法,參數傳遞字符串和3個Lambda表達式
        int num = change(str,(String s)->{
            //"趙麗穎,20"->"20"
           return s.split(",")[1];
        },(String s)->{
            //"20"->20
            return Integer.parseInt(s);
        },(Integer i)->{
            //20->120
            return i+100;
        });
        System.out.println(num);
    }
}