博客

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

  • Post author:
  • Post category:java



目录


接口的默认方法


接口的静态方法


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

public class Main{
    public static void main(String[] args) {
        ArrayList<String> 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<String> 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<Integer> 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<T>接口为例，其中只有一个 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<T>

代表了接受一个输入参数并且无返回的操作

2
Function<T,R>

接受一个输入参数，返回一个结果。

3
Predicate<T>

接受一个输入参数，返回一个布尔值结果。

4
Supplier<T>

无参数，返回一个结果。

5
UnaryOperator<T>

接受一个参数为类型T,返回值类型也为T。

示例： 

/**
* @Author:         QianQian
* @CreateDate:     2019/11/30 17:17
*/
public class Main{
    public static void main(String[] args) {
        ArrayList<Integer> 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,返回值类型也为T。
        arrayList.forEach(System.out::println);
    }
}

运行结果：







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




?


版权声明：本文为qq_42013035原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Tags: