1 package day14.lesson1;
 2 
 3 /*
 4 1 函式式介面
 5 
 6 1.1 函式式介面概述
 7 
 8     概念
 9         有且僅有一個抽象方法的介面
10         java中的函數語言程式設計體現就是Lambda表示式，所以函式式介面就是可以適用於Lambda使用的介面
11         只有確保介面中有且僅有一個抽象方法，java中的Lambda才能順利進行推導
12     如何檢測一個介面是不是函式式介面
13         @FunctionalInterface
14         放在介面定義的上方：如果介面是函式式介面，編譯通過；如果不是，編譯失敗
 
15     注意事項
16         我們自己定義函式式介面的時候，@FunctionalInterface是可選的，就算我不寫這個註解，只要保證滿足函式
17         式介面定義的條件，也照樣是函式式介面。但是，建議加上該註解
18  */
19 public class Demo1MyInter {
20     public static void main(String[] args) {
21         MyInter mi = () -> System.out.println("函式式介面"); // 根據區域性變數的賦值得知Lambda對應的介面https://www.cnblogs.com/yppah/p/14874679.html
 

22         mi.show();
23     }
24 }
25 
26 @FunctionalInterface
27 interface MyInter{
28     void show();
29 
30 //    void method(); //註解FunctionalInterface編譯異常
31 }

 1 package day14.lesson1;
 2 
 3 /*
 4 1.2 函式式介面作為方法的引數
 5 
 6     需求描述
 7         定義一個類(RunnableDemo)，在類中提供兩個方法
 8         一個方法是：startThread(Runnable r) 方法引數Runnable是一個函式式介面
 
 9         一個方法是主方法，在主方法中呼叫startThread方法
10  */
11 public class Demo2Runnable {
12     public static void main(String[] args) {
13         // 匿名內部類
14         startThread(new Runnable() {
15             @Override
16             public void run() {
17                 System.out.println(Thread.currentThread().getName() + "執行緒啟動了");
18             }
19         });
20 
21         // Lambda表示式
22         startThread(() -> System.out.println(Thread.currentThread().getName() + "執行緒啟動了"));
23         // 如果方法的引數是一個函式式介面，則可以使用Lambda表示式作為引數傳遞
24     }
25 
26     private static void startThread(Runnable r){ // Runnable是函式式介面，可以作為形參
27         /*Thread t = new Thread(r);
28         t.start();*/
29         new Thread(r).start();
30     }
31 
32 //    Runnable原始碼
33 //    @FunctionalInterface
34 //    public interface Runnable {
35 //        /**
36 //         * When an object implementing interface <code>Runnable</code> is used
37 //         * to create a thread, starting the thread causes the object's
38 //         * <code>run</code> method to be called in that separately executing
39 //         * thread.
40 //         * <p>
41 //         * The general contract of the method <code>run</code> is that it may
42 //         * take any action whatsoever.
43 //         *
44 //         * @see     java.lang.Thread#run()
45 //         */
46 //        public abstract void run();
47 //    }
48 }

 1 package day14.lesson1;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.Comparator;
 6 
 7 /*
 8 1.3 函式式介面作為方法的返回值
 9 
10     需求描述
11         定義一個類(ComparatorDemo)，在類中提供兩個方法
12         一個方法是：Comparator<String> getComparator() 方法返回值Comparator是一個函式式介面
13         一個方法是主方法，在主方法中呼叫getComparator方法
14  */
15 public class Demo3Comparator {
16     public static void main(String[] args) {
17         ArrayList<String> arrayList = new ArrayList<>();
18         arrayList.add("ccc");
19         arrayList.add("aa");
20         arrayList.add("e");
21         arrayList.add("dddd");
22         arrayList.add("bbbbb");
23         System.out.println("排序前：" + arrayList); // [ccc, aa, e, dddd, bbbbb]
24 
25 //        Collections.sort(arrayList); // [aa, bbbbb, ccc, dddd, e] 自然順序(按字母順序)排序
26 
27         /*Collections.sort(arrayList, new Comparator<String>() {
28             @Override
29             public int compare(String s1, String s2) {
30                 return s1.length() - s2.length();
31             }
32         }); // [e, aa, ccc, dddd, bbbbb] 按字串長度排序*/
33 
34         Collections.sort(arrayList, getComparator()); // 效果同上
35 
36         System.out.println("排序後：" + arrayList);
37     }
38 
39     private static Comparator<String> getComparator(){ // Comparator是函式式介面
40         //匿名內部類
41         /*Comparator<String> comparator = new Comparator<String>(){
42             @Override
43             public int compare(String s1, String s2) {
44                 return s1.length() - s2.length();
45             }
46         };
47         return comparator;*/
48 //        return new Comparator<String>() {
49 //            @Override
50 //            public int compare(String s1, String s2) {
51 //                return s1.length() - s2.length();
52 //            }
53 //        };
54 
55         // Lambda表示式
56         /*return (String s1, String s2) -> {
57             return s1.length() - s2.length();
58         };*/
59         return (s1, s2) -> s1.length()-s2.length();
60         // 如果方法的返回值是一個函式式介面，則可以使用Lambda表示式作為結果返回
61     }
62 
63 //    Comparator原始碼
64 //    @FunctionalInterface
65 //    public interface Comparator<T> {...}
66 }