371-373 函数式接口

373 函数式接口

函数式接口，就是有且仅有1个抽象方法的接口

（LambDa表达式的使用前提）

---------------------------------------------

package e373;

@FunctionalInterface

//@FunctionalInterface是函数式接口的标识，写上之后，这个接口中只允许且必须写1个抽象方法。在写好的接口上写@FunctionalInterface，可以检验这个接口是否函数式接口，是则不报错，不是则报错。@FunctionalInterface可写可不写，建议写上。

public interface Jiekou373 {

    void show();

}

---------------------------------------------

package e373;

public class Demo {

    public static void main(String[] args) {

        Jiekou373 j373 = () -> System.out.println("functionalInterface");

//        函数式接口可以用作方法参数传递，也可以用作局部变量的.

//        这里把它用作局部变量.它用作局部变量时，可以用LambDa表达式赋值给它

        j373.show();

    }

}

//functionalInterface

374 函数式接口作为方法的参数

函数式接口作为方法的参数，例如Runnable

（参数可以是变量、数组、集合、类、对象、接口）

【练习需求】

定义一个Demo374类，定义一个startThread方法并调用，参数是Runnable接口

---------------------------------------------

package e374;

public class Demo374 {

    public static void main(String[] args) {

//anonymous inner class

        startThread(new Runnable() {

            @Override

            public void run() {

                System.out.println(Thread.currentThread().getName() + ":the thread starts by anonymous inner class.");

            }

        });

//lambda

        startThread(() -> System.out.println(Thread.currentThread().getName() + ":the thread starts by lambda."));

    }

    private static void startThread(Runnable r) {

//        Runnable is a functional interface.

//        Thread t=new Thread(r);

//        t.start();

        new Thread(r).start();

    }

}

//Thread-0:the thread starts by anonymous inner class.

//Thread-1:the thread starts by lambda.

375 函数式接口作为方法的返回值

如果方法的返回值是一个函数式交口，就可以使用LambDa表达式作为返回结果

    private static Comparator<String> getComparator() {

        return (s1, s2) -> s1.length() - s2.length();

    }

【练习需求】

定义一个Demo类，定义一个Comparator<String> getComparator()方法，返回值、参数如写，并调用。

---------------------------------------------

package e375;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

public class Demo375 {

    public static void main(String[] args) {

        ArrayList<String> al = new ArrayList<>();

        al.add("bean");

        al.add("zoo");

        al.add("apple");

        System.out.println("original order:" + al);

        Collections.sort(al);

        System.out.println("natural order:" + al);

        Collections.sort(al, getComparator());

        System.out.println("custom order:" + al);

    }

    private static Comparator<String> getComparator() {

//anonymous inner class 1

//        Comparator is a functional interface.

//        Comparator<String> c=new Comparator<String>() {

//            @Override

//            public int compare(String s1, String s2) {

//                return s1.length()-s2.length();

//            }

//        };

//        return c;

//anonymous inner class 2

//        return new Comparator<String>() {

//            @Override

//            public int compare(String s1, String s2) {

//                return s1.length() - s2.length();

//            }

//        };

//lambda

        return (s1, s2) -> s1.length() - s2.length();

    }

}

//original order:[bean, zoo, apple]

//natural order:[apple, bean, zoo]

//custom order:[zoo, bean, apple]