JDK 8新特性 ——接口与函数式接口

一、接口

1.1 接口组成更新概述

• 常量

public static final 可以省略

• 抽象方法

public abstract 可以省略

• 默认方法（since java8）

如下图所示

• 静态方法（since java8）

如下图所示

• 私有方法（since java9）

1.2 默认方法

1.2.1 使用场景

假设我们已经存在一个劲接口MyInterface，但是随着业务的进行我们还需要在MyInterface接口中增加一个方法，但是如果我们增加的话，他的每个实现类都需要将这个方法进行实现。

此时有一个坏处，并不是每个类都能使用到这个接口，那我们就重新创建一个接口MyInterfaceSon去继承MyInterface接口，并且写上想增加的方法，如果有类想要使用这个方法，直接可以实现MyInterfaceSon这个类。 但是这样用的话，以后还是会出现想用的问题

public interface MyInterfaceSon extends MyInterface{
}

那我们就可以在接口中使用默认方法，如下所示，当我们添加一个默认方法后，实现MyInterface的类可以选择实现方法show3，也可以选择不实现，很人性化

public interface MyInterface {
    void show1();
    void show2();

    public default void show3(){
    }
}

总结来说：方法的升级不会破坏现有的代码

1.2.2 默认方法的使用

public default 返回值类型 方法名(参数列表){ }

其中 public是可以省略的

 public interface MyInterface {
    void show1();
    void show2();

    public default void show3(){
//    方法体
    }
}

当我们给MyInterface接口多加了一个default方法后，下面的实现类并没有报错

当我们子类实现show3方法的时候，发现没有default这个关键字了，一定要注意

1.3 静态方法

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

public static 返回值类型 方法名(参数列表){}

public可以省略

    public static  void show(){
    }

1.3.1 静态方法的使用

public interface Inter {
    void show();
    default void method(){
        System.out.println("Inter中的默认方法执行了");
    }
    public static void test(){
        System.out.println("Inter中的静态方法执行了");
    }
}

public class InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("show方法执行了");
    }
}

然后我们发现我们掉用不了静态的test方法

静态方法只能在包含接口类上调用
Static method may be invoked on containing interface class only

为什么只能通过类来调用呢？
假设 InterImpl这个实现类实现了好几个接口，并且每个接口中都有test静态方法，那如果此时再通过实例对象调用，编译器将不会知道调用哪个接口的test方法

1.4 私有方法(Java9)

1.4.1 接口中的私有方法

Java 9 中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。

这样可能会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段代码抽取成一个共性的方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

格式：

private 返回值类型 方法名(参数列表){}

private static 返回值类型 方法名(参数列表){}

示例：

private void show(){}

private static void method(){}

1.4.2 接口中私有方法的使用

一定要注意！！！！

默认方法可以调用私有静态方法，但是静态方法无法调用私有默认方法

自我理解出现这种情况的原因：
其实说白了和这个根本没有关系，其实和 方法是不是静态方法或者是实例方法有关。
我为什么这么说呢，我解释一下

静态方法什么时候被加载呢？
当然是在class文件被加载的时候，也就是说在方法区就被加载了

实例方法什么时候被加载？
在程序运行过程中类实例化后才会存在。

那这样说来就很清晰了，即我们不实例化我们也是可以使用静态方法的，但是不可以使用实例方法。 那如果我们在静态方法中调用了实例方法，但我没有对此类进行实例化，那肯定是不符合要求的呀，你 没有实例化怎么能在静态方法中调用实例方法呢？

public class InterImpl implements Inter{
}

public interface Inter {
    default void show1() {
        System.out.println("show1开始执行");
//        抽取下面的三行
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        show();
        System.out.println("show1结束执行");
    }

    default void show2() {
        System.out.println("show2开始执行");
//        抽取下面的三行
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        show();
        System.out.println("show2结束执行");
    }

    private void show() {

        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }

    static void method1() {
        System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        method();
        System.out.println("method1结束执行");
    }

    static void method2() {
        System.out.println("method2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        method()
        System.out.println("method2结束执行");
    }

    private static void method() {
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
}

public class InterDemo {
    public static void main(String[] args) {
//    按照多态的方式创建对象并使用
        Inter i = new InterImpl();
        i.show1();
        System.out.println("----------");
        i.show2();
        System.out.println("----------");
        Inter.method1();
        System.out.println("----------");
        Inter.method2();
    }
}

二、引用

对lambda表达式不熟悉可以看下面的文章
(45条消息) JDK 8新特性——Lambda表达式_我爱布朗熊的博客-CSDN博客

2.1 体验方法引用

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方法：拿参数做操作

那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同的方案，那是否还有必要再重写逻辑呢？那我们如何使用已经存在的解决方案的呢？

@FunctionalInterface
public interface Printable {
    void printString(String s);
}

public class PrintableDemo {
    public static void main(String[] args) {
//     第一种写法： lambda表达式
       usePrintable( (s -> System.out.println(s)));
        System.out.println("****************");

//     第二种写法：lambda表达式
        Printable printable = (s) -> {
            System.out.println(s);
        };
        usePrintable(printable);
        System.out.println("****************");

//     第三种写法：方法引用符 ::
//           System.out是一个对象，我们要调用此对象下的println方法
        usePrintable(System.out::println);
    }

    private static void usePrintable(Printable p){
        p.printString("爱生活爱Java");
    }
}

2.2 方法引用符

如果使用Lambda，那么根据"可推导就是可省略"的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导。如果使用方法引用，也是同样可以根据上下文进行推导

• :: 双冒号，引用运算符，而它所在的表达式被称为方法引用

usePrintable(System.out::println);

直接使用System.out中的println方法来取代Lambda，代码更加的简洁

• 对比一下lambda表达式

usePrintable( (s -> System.out.println(s)));

分析： 拿到参数s之后通过Lambda表达式，传递给System.out.println方法去处理

2.3 引用类方法(静态方法)

• 格式： 类名::静态方法

• 范例： Integer::parseInt

Integer类的方法，public static int parseInt(String s) 将此String转换为int类型的数据

@FunctionalInterface
public interface Converter {
    int convert(String s);
}

public class ConverterDemo {
    public static void main(String[] args) {
//    1.匿名内部类表达式
        useConverter(new Converter() {
            @Override
            public int convert(String s) {
                return Integer.parseInt(s);
            }
        });

//    2.lambda表达式
//        Converter converter = (String s) -> {
//            return Integer.parseInt(s);
//        };
//        useConverter(converter);
        useConverter((String s) -> {
            return Integer.parseInt(s);
        });

//     3.引用类方法
//         lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
        useConverter(Integer::parseInt);
    }

    private static void useConverter(Converter c){
        int number = c.convert("666");
        System.out.println(number);
    }
}

2.4 引用对象的实例方法(成员方法)

其实就是引用类中的成员方法、

• 格式： 对象::成员方法

• 范例： "HelloWord"::toUpperCase

String类中的方法：public String toUpperCase() 将此String所有字符转换成大写

public class PrinterDemo {
    public static void main(String[] args) {
//      1.Lambda表达式
        userPrinter((String s) ->{
            String result = s.toUpperCase();
            System.out.println(result);
        });

//      2.引用成员方法
        PrintString printString = new PrintString();
        userPrinter(printString::printUpper);
    }

    private static void userPrinter(Printer p) {
        p.printUpperCase("HelloWord");

    }
}

public interface Printer {
    void printUpperCase(String s);
}

public class PrintString {
    public void printUpper(String s){
        System.out.println(s.toUpperCase());
    }
}

2.5引用类的实例方法

其实就是引用类中的成员方法

• 格式： 类名::成员方法

• 范例： String::substring

String类中的方法：public String substring(int beginIndex, int endIndex) 从beginIndex开始到endIndex结束，截取字符串，返回一个子串，子串的长度为endIndex-beginIndex

public interface MyString {
    String mySubString(String s,int x,int y);
}

public class MyStringDemo {
    public static void main(String[] args) {
//      1.lambda表达式的形式
         useMyString((s,x,y)->{
             String substring = s.substring(x, y);
             return  substring;
         });

//       2.方法引用
        useMyString(String::substring);
    }

    public static void useMyString(MyString my){
        String s = my.mySubString("HelloWorld", 2, 5);
        System.out.println(s);
    }
}

2.6 引用构造器

引用构造器，其实就是引用构造方法

• 格式： 类名:: new

• 范例： Student::new

三、函数式接口

3.1 概述

函数式接口： 有且仅有一个抽象方法的接口

Java中的函数式变成体现就是lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

public interface MyInterface {
    void show();
}

public class MyInterfaceDemo {
    public static void main(String[] args) {

       MyInterface my  = ()->{
           System.out.println("函数式接口");
       };

       my.show();
    }
}

但是对于MyInterface接口，我们知道其有一个方法，知道是函数式接口，那万一以后有人再修改接口，新增加抽象方法，那岂不是我们在Demo中的程序无法运行了？

答案： 是的！

为了避免这种情况，我们可以在接口上使用@FunctionalInterface注解，用意是标注此接口为函数式接口

@FunctionalInterface
public interface MyInterface {
    void show();
}

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

public class RunnableDemo {
    public static void main(String[] args) {
//      1.匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });

//      2.lambda表达式
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"线程启动了");
        });

//        2.1更清晰的写法
        Runnable runnable =()->{
            System.out.println(Thread.currentThread().getName()+"线程启动了");
        };
        startThread(runnable);

    }

//  Runnable 接口是函数式接口
    public static void startThread(Runnable r){
//        Thread t = new Thread(r);
//        t.start();
        new Thread(r).start();
    }
}

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

很明显，我们的返回值类型是一个函数式接口

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("cccc");
        arrayList.add("aa");
        arrayList.add("b");
        arrayList.add("saff");
        System.out.println("排序前："+arrayList);

//      排序
        Collections.sort(arrayList,getComparator());
        System.out.println("排序后："+arrayList);
    }

    private static Comparator<String> getComparator(){
      Comparator<String> comp = new Comparator<String>() {
          @Override
          public int compare(String o1, String o2) {
              return o1.length()-o2.length();
          }
      };
      return comp;
//      比较的逻辑也能使用Lambda表达式的形式
//        return (s1,s2)->{
//            return s1.length()-s2.length();
//        };
    }
}

3.4 常用的函数式接口

3.4.1 Supplier

Supplier<T>:包含一个无参的方法

• T get(): 获得结果

• 该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据

• Supplier<T> 接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

public class SupplierDemo {
    public static void main(String[] args) {
//      写法1：
        String string1 = getString(() -> {
            return "林青霞";
        });
        System.out.println(string1);

//      写法2：
        Supplier<String> supplier =  ()->{
            return "林青霞";
        };
        String string2 = getString(supplier);
        System.out.println(string2);

    } 
//    定义一个方法，返回字符串数据
    private static String getString(Supplier<String> supplier){
        return supplier.get();
    }
}

3.4.1.1 Supplier接口获取最大值

public class SupplierTest {
    public static void main(String[] args) {
//       定义一个int数组
        int[] arr= {19,50,28,37,46};

        int maxNum = getMax(() -> {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxNum);
    }

    private static int getMax(Supplier<Integer> supplier){
        return supplier.get();
    }
}

3.4.2 Consumer接口 消费型接口

Consumer<T> 包含两个方法

Consumer接口也称为消费型接口，它消费的数据的数据类型由泛型指定

• void accept(T t): 对给定的参数执行此操作

• default Consumer<T> andThen(Consumer after): 返回一个组合的Consumer，依次执行此操作，然后执行after操作

public class ConsumerDemo {
    public static void main(String[] args) {
        operatorString("林青霞", (String s) -> {
            System.out.println(s);
        });
    }

    private static void operatorString(String name, Consumer<String> consumer) {
        consumer.accept(name);
    }
}

3.4.2.1 Consumer—按要求打印信息

• String[] strArray={"林青霞,30" , "张曼玉,35" , "王祖贤,33" };

• 字符串数组中有多条信息，请按照格式："姓名：xx，年龄：xx"的格式将信息打印出来

• 要求：

把打印姓名的动作作为第一个Consumer接口的Lambda实例

把打印年龄的动作作为第二个Consumer接口的Lambda实例

将两个Consumer接口按照顺序组合到一起使用

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray={"林青霞,30" , "张曼玉,35" , "王祖贤,33" };

        printInfo(strArray,(String str)->{
            String name = str.split(",")[0];
            System.out.println("姓名："+name);
        },(String str)->{
            int age = Integer.parseInt(str.split(",")[1]);
            System.out.println("年龄："+age);
        });

    }
    private static void printInfo(String[] strArry, Consumer<String> con1,Consumer<String> con2){
        for (String str: strArry){
            con1.andThen(con2).accept(str);
        }
    }
}

3.4.3 Predicate

表示对一个参数进行判断的，返回一个布尔值

下图是Api文档中对Predicate接口方法的描述

• Predicate<T>:常用的四个方法

• boolean test(T t):对给定的参数进行判断(判断罗辑由Lambda表达式实现)，返回一个布尔值

• default Predicate<T>negate0:返回一个逻辑的否定，对应逻辑非default

• Predicate<T>and(Predicate other): 返回一个组合判断，对应短路与

• defaultPredicate<T>or(Predicate other): 返回一个组合判断，对应短路或

3.4.3.1 Predicate<T> 接口通常用于判断参数是否满足指定的条件

public class PredicateDemo01 {
    public static void main(String[] args) {
        boolean b = checkString("hello", (String s) -> {
            return s.length() > 8;
        });
        System.out.println(b);
    }
    private static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }
}

3.4.3.2 negate逻辑非的运算

    private static boolean checkString(String s, Predicate<String> pre){
//        return !pre.test(s);   这种情况是我们之前的饿用法
        return pre.negate().test(s);
    }

3.4.3.3 组合判断，对应短路与

public class PredicateDemo01 {
    public static void main(String[] args) {

        boolean b = checkString("hello",
                (String s) -> {
                    return s.length() > 8;
                },
                (String s) -> {
                    return s.length() <15;
                });
        System.out.println(b);
    }

    //  同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
//        
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1 && b2;
//        return b;
        return pre1.and(pre2).test(s);
    }
}

3.4.3.4 组合判断，对应短路或

    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {

        return pre1.or(pre2).test(s);
    }

3.4.3.5 筛选满足条件的数据

• String[] strArray={"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};

• 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符审筛选到集合ArraList中，并遍历ArrayList

• 集合同时满足如下要求:姓名长度大于2;年龄大于33

public class PredicateDemo02 {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
        ArrayList<String> arrayList = myFilter(strArray,
                (String s) -> {
                    return s.split(",")[0].length() > 2;
                }, (String s) -> {
                    return Integer.parseInt( s.split(",")[1])>33;
                });
        System.out.println(arrayList);
    }

    private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
        ArrayList<String> arrayList = new ArrayList<>();
//    便利数组
        for (String str : strArray) {
            if (pre1.and(pre2).test(str)) {
                arrayList.add(str);
            }

        }
        return arrayList;
    }
}

3.4.4 Function

Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

• R apply(T t): 将此函数应用于给定的参数

• default<V> Function andThen(Function after): 返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

public class FunctionDemo {
    public static void main(String[] args) {
        convert("100",(String s)->{
            return Integer.parseInt(s);
        });
    }
//  将String转化为integer
    private static void convert(String s, Function<String, Integer> function){
        Integer apply = function.apply(s);
        System.out.println(apply);
    }
}

3.4.4.1 按照指定要求操作数据

• String s="林青霞,30"

• 请按照我指定的要求进行操作:

• 1:将字符串截取得到数字年龄部分

• 2:将上一步的年龄字特串转换成为int类型的数据

• 3:将上一步的int数据加70，得到一个int结果，在控制台输出请通过Function接口来实现函数拼接

public class FunctionDemo {
    public static void main(String[] args) {

        convert("林青霞,30",
                (String s) -> {
//                  提取出30
                    return s.split(",")[1];
                },
//               将字符串转换成Integer
                s1 -> {
                     return Integer.parseInt(s1);
                },
//              将这个数加70
                s2 -> {
                    return s2+70;
                }
                );
    }

    //  将String转化为integer
    private static void convert(String s, Function<String, String> function1, Function<String, Integer> function2, Function<Integer, Integer> function3) {
//        Integer apply = function1.apply(s);
//        System.out.println(apply);
        Integer integer = function1.andThen(function2).andThen(function3).apply(s);
        System.out.println(integer);
    }
}