Java8 新特性之 Lambda，接口默认方法，函数式接口

目录

接口的默认方法

接口的静态方法

lambda基本语法

方法的引用与lambda表达式的关系

lambda表达式的应用示例

一. Runnable接口的实现

二. 集合的排序：

函数式接口

---

接口的默认方法

为啥要有这个新特性？举个栗子，在Java8之前，在Itreable接口中还没有forEach()方法，如果在发布Java8时，以接口的默认的（public abstract)关键字来修饰它的话，那么那些之前实现Iterable接口的类就不得不全部重写一遍这个方法，所以Java8允许接口有默认的实现方法，使用default修饰，接口的实现类可以不去覆写这些方法，它的目的是为了解决接口的修改与现有的实现不兼容的问题。

代码示例：

public class Main implements FunctionInerface{
    public static void main(String[] args) {
        Main main=new Main();
        main.hello();
        main.print();
    }
    @Override
    public void hello() {
        System.out.println("我是接口的未实现方法");
        FunctionInerface.super.print();
    }
}

interface FunctionInerface{
    void hello();
    default void print(){
        System.out.println("我是接口的默认方法");
    }
}

运行结果：

接口的静态方法

接口的静态方法可以直接使用接口名调用

public class Main{
    public static void main(String[] args) {
        FunctionInerface.print();
    }
}

interface FunctionInerface{
    static void print(){
        System.out.println("我是接口的静态方法");
    }
}

运行结果：

lambda基本语法

首先，lambda表达式并不是一个必须的存在，它的出现是为了简化接口的实现，传统的接口实现主要由两类：

• 使用实现类实现接口中的方法，然后通过该类调用接口中的方法
• 使用匿名内部类的方法

而当接口中只有一个抽象方法时(这类接口被称作为函数式接口，使用@FunctionalInterface注释，如果接口中不止一个抽象方法时，此注释会报错），这时可以使用大lambda表达式来简化接口的实现，关于常用的函数式接口，可参考我的另一篇博文：https://blog.csdn.net/qq_42013035/article/details/103325825

示例代码就六种不同的函数结构给出了其lambda表达式的实现：

注意：

1. lambda表达式是通过对接口中唯一抽象方法的实现，来达到类似于匿名内部类的实现效果，语法为（方法参数）->{方法体}
2. 方法参数可以写作 (int a,int b) 的形式，也可写作（a,b) 的形式，但不能写作（int a,b) 这种
3. 如果方法体只用一条语句，例如：return a+b; 那么可以去掉大括号，简化为 （a,b)->a+b,

package com;

/**
* @Author:         QianQian
* @CreateDate:     2019/11/30 17:17
*/
public class Main{
    public static void main(String[] args) {
        NoReturnNoParameter noReturnNoParameter=()-> System.out.println("无返回值无参数");
        noReturnNoParameter.hello();
        NoReturnHaveOneParameter noReturnHaveOneParameter=a -> System.out.println("无返回值有一个参数："+a);
        noReturnHaveOneParameter.hello(100);
        NoReturnHaveTwoParameter noReturnHaveTwoParameter=(a,b)-> System.out.println("无返回值有两个参数："+a+","+b);
        noReturnHaveTwoParameter.hello(55,23);
        HaveReturnNoParameter haveReturnNoParameter=()->999;
        System.out.println(haveReturnNoParameter.hello());
        HaveReturnHaveOneParameter haveReturnHaveOneParameter=(a)->a*100;
        System.out.println(haveReturnHaveOneParameter.hello(22));
        HaveReturnHaveTwoParameter haveReturnHaveTwoParameter=(a,b)->{
            int m=a*2;
            return m*b;
        };
        System.out.println(haveReturnHaveTwoParameter.hello(30,20));
    }
}
@FunctionalInterface
interface NoReturnNoParameter{
    void hello();
}
@FunctionalInterface
interface NoReturnHaveOneParameter{
    void hello(int a);
}
@FunctionalInterface
interface  NoReturnHaveTwoParameter{
    void hello(int a,int b);
}
@FunctionalInterface
interface HaveReturnNoParameter{
    int hello();
}
@FunctionalInterface
interface HaveReturnHaveOneParameter{
    int hello(int a);
}
@FunctionalInterface
interface  HaveReturnHaveTwoParameter{
    int hello(int a,int b);
}

运行结果： 

 

方法的引用与lambda表达式的关系

当在程序中要多次使用到一个接口，那么就要多次实现 lambda 表达式，如果此时要对接口的实现进行修改，那么就不得吧每一处实现都修改一次，甚是麻烦，所以此处就使用到方法的引用，如下实例：

public class Main{
    public static void main(String[] args) {
        TestInterface testInterface=(a,b)->a+b;
        System.out.println(testInterface.hello(20,30));
        TestInterface testInterface1=Main::test;
        System.out.println(testInterface1.hello(22,32));
    }
    public static int test(int a,int b){
        System.out.println("方法被引用");
        return a+b;
    }
}

@FunctionalInterface
interface TestInterface{
    int hello(int a,int b);
}

运行结果：

可见，可以引用一个参数和返回值与抽象方法相同的方法，用来替代此处的lambda表达式，增加程序的可维护性。

再拿 Iterable 接口中的 forEach() 来举个栗子！

使用 forEach(Consumer action) 可以对集合中的每个元素执行指定的操作，函数传入一个函数式的接口Consumer，该接口只有一个抽象方法void accept(T t) ，可对给定的参数进行操作（此处参数即为集合中的每个元素），故我们可以通过如下的lambda表达式返回此接口：

public class Main{
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList<>();
        arrayList.add("Monday");
        arrayList.add("Tuesday");
        arrayList.add("Wednesday");
        arrayList.forEach((t)-> System.out.println(t));
    }
}

运行结果：

但仔细观察如下PrintStream中的println函数，会发现它的结构和 accept(T t) 的返回值和参数相同，故我们可以引用这个函数来简化lambda表达式：

 public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

简化：

public class Main{
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList<>();
        arrayList.add("Monday");
        arrayList.add("Tuesday");
        arrayList.add("Wednesday");
        arrayList.forEach(System.out::println);
    }
}

结果与上相同

 

lambda表达式的应用示例

一. Runnable接口的实现

因为runnable接口中只用一个 run() 故它也是个 @FunctinalInterface,使用lambda表达式构建一个线程如下

public class Main{
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            System.out.println("hello world");
        });
        thread.start();
    }
}

结果：

二. 集合的排序：

public class Main{
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList<>();
        arrayList.add(5);
        arrayList.add(2);
        arrayList.add(9);
        arrayList.add(6);
        arrayList.add(2);
        arrayList.add(4);
        arrayList.forEach(System.out::print);
        arrayList.sort((a,b)->a-b);//传入一个Comparator接口
        System.out.println("\n排序后");
        arrayList.forEach(System.out::print);
    }
}

结果：

Comparator 接口是java.util包下的一个函数式接口，此处用lambda表达式实现其唯一的抽象方法 compare（T t0,T t1),确定排序的规则

 

函数式接口

函数式接口就是具有一个未实现的方法的接口  （所以不包括接口的默认方法和静态方法）

函数式接口存在的意义是可以很好的支持lambda表达式

函数式接口使用@FunctionalInterface进行注解

以java.util.function.Consumer接口为例，其中只有一个 accept(T t) 的无返回值方法，使用lambda实现代码如下：

public class Main{
    public static void main(String[] args) {
        Consumer consumer=(a)-> System.out.println(a);
        consumer.accept("who are you");
    }
}

运行结果：

JDK 1.8之前已有的函数式接口:

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：

• java.util.function.*

该包下常用的函数式接口如下表：

序号	接口 & 描述
1	Consumer 代表了接受一个输入参数并且无返回的操作
2	Function 接受一个输入参数，返回一个结果。
3	Predicate 接受一个输入参数，返回一个布尔值结果。
4	Supplier 无参数，返回一个结果。
5	UnaryOperator 接受一个参数为类型T,返回值类型也为T。

示例：

/**
* @Author:         QianQian
* @CreateDate:     2019/11/30 17:17
*/
public class Main{
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList<>();
        arrayList.add(5);
        arrayList.add(2);
        arrayList.add(9);
        arrayList.add(6);
        arrayList.add(2);
        arrayList.add(4);
        arrayList.replaceAll((t)-> t+100);//传入一个UnaryOperator接口，接受一个参数为类型T,返回值类型也为T。
        arrayList.forEach(System.out::println);
    }
}

运行结果：

 

                                                                         OK啦，觉得海星点个赞呗！