深入理解Java Lambda表达式(全网之最)

本文将结合书本和网络教程,阐述自己对于Lambda表达式的理解,如有偏差,欢迎指正…

目录

什么是Lambda表达式?

为什么要引入Lambda表达式?

Lambda表达式的语法:

Lambda表达式的分类

什么是函数式接口?

         函数式接口有什么作用?

自定义一个函数式接口:

四大函数式接口:

方法引用:

 技术的进步,循序渐进;慢下来,扎扎实实;用过度的功夫,才能理解表面肤浅的深度

什么是Lambda表达式?

可以将Lambda表达式理解为一个匿名函数; Lambda表达式允许将一个函数作为另外一个函数的参数; 我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码作为实参),也可以理解为函数式编程,将一个函数作为参数进行传递

为什么要引入Lambda表达式?

这就好像小强看到小明的手里拿了一把玩具手枪,自己也想拥有一把一样。当java程序员看到其他语言的程序员(如JS,Python)在使用闭包或者Lambda表达式的时候,于是开始吐槽世界上使用最广的语言居然不支持函数式编程。千呼万唤,Java8推出了Lambda表达式。

Lambda表达式能够让程序员的编程更加高效

让我们先来看一段代码:

package com.isea.java;
public class TestLambda {
       public static void main(String[] args) {
       Thread thread = new Thread(new MyRunnable());
       thread.start();
       thread.close();
    }
}
class MyRunnable implements Runnable{
	    @Override
        public void run() {
            System.out.println("Hello");
        }
}

为了使这段代码变得更加简洁,可以使用匿名内部类重构一下(注意代码中的注释)

package com.isea.java;
public class TestLambda {
    public static void main(String[] args) {
        new Thread(new Runnable() {
        //这里的new Runnable(),这里new 了接口,在这个new的接口里面,我们写了这个接口的实现类。
        //这里可以看出,我们把一个重写的run()方法传入了一个构造函数中。
            @Override
            public void run() {
                System.out.println("Hello");
            }
        }).start();
    }
}

上面的代码可以换成这样的,我们将new 的接口,赋值给线程的引用:

package com.isea.java;

public class TestLambda {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello");
            }
        });
        thread.start();
    }
}

而上面的这段代码,不是最简单的,还可以进一步简化

package com.isea.java;
public class TestLambda {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Hello")).start();
    }
}//这里new Thread(() -> System.out.println("Hello"));同样实现了将一段代码传入了构造方法中

怎么样?是不是很酷?我想上面的三段代码已经成功的想你展示了Lambda表达式能够让程序员的编程更叫高效这话是真的!假如之前没有接触过函数式编程的话,即便已经体会到了Lambda表达式能够减少代码量,省掉不少手力,也为这逻辑,感到很费脑力。孰能生巧,还记得当年打9*9的乘法表的时候,也觉得很难不是么?

Lambda表达式的语法:

([Lambda参数列表,即形参列表]) -> {Lambda体,即方法体}

拷贝小括号,写死右箭头,落地大括号,大括号中写上业务逻辑

@Functionalnterface

default

静态方法

特点:使用 “->”将参数和实现逻辑分离;( ) 中的部分是需要传入Lambda体中的参数;{ } 中部分,接收来自 ( ) 中的参数,完成一定的功能。

Lambda表达式的分类

  • 无参无返回值
package com.isea.java;
public class TestLambda {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Hello"));
    }
}//()中无参数,也不能省略;{}中只有一句话,建议省略。
  • 有参无返回值
package com.isea.java;
import java.util.ArrayList;
public class TestLambda {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("AAAAA");
        list.add("BBBBB");
        list.add("CCCCC");
        list.add("DDDDD");
//形参的类型是确定的,可省略;只有一个形参,()可以省略;
        list.forEach(t -> System.out.print(t + "\t"));
//或者更简洁的方法引用:list.forEach(System.out::println);
        //打印结果:AAAAA	BBBBB	CCCCC	DDDDD
    }
}

public void forEach(Consumer<? super E> action)

forEach()  功能等同与增强型for循环 这个方法来自于Iterable接口,Collection接口继承了这个接口,List又继承了Collection接口,而ArrayList是List的实现类;forEach函数,指明该函数需要传入一个函数,而且是有参数没有返回值的函数,而Consumer接口中正好有且仅有一个这样的有参无返回值的抽象方法。接下来,我们会了解到这是使用Lambda的必要条件。

void accept(T t);// from source code

  • 无参有返回值
package com.isea.java;
import java.util.Random;
import java.util.stream.Stream;
public class TestLambda {
    public static void main(String[] args) {
        Random random = new Random();
        Stream<Integer> stream = Stream.generate(() ->random.nextInt(100));
        stream.forEach(t -> System.out.println(t));
    }//只有一个return,可以省略return;该方法将会不断的打印100以内的正整数。
}//Stream.generate()方法创建无限流,该方法要求传入一个无参有返回值的方法。

public static<T> Stream<T> generate(Supplier<T> s) //来自源码

  • 有参有返回值

这个例子,相对较长,请揉揉眼睛,需求:按照学生的姓名对学生进行排序(使用Collator 文本校对器排序)

package com.isea.java;
import java.text.Collator;
import java.util.TreeSet;

public class TestLambda {
    public static void main(String[] args) {
        Collator collator = Collator.getInstance();
        TreeSet<Student> set = new TreeSet<>((s1,s2) -> collator.compare(s1.getName(),s2.getName()));
        set.add(new Student(10,"张飞"));
        set.add(new Student(3,"周瑜"));
        set.add(new Student(1,"宋江"));
        set.forEach(student -> System.out.println(student));
    }
}//这里的Collator是一个抽象类,但是提供了获取该类实例的方法getInstance()

class Student{
    private int id;
    private String name;
    
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

其实,这个例子,也不是很长。到此,我们就讲完了Lambda表达式的分类,参数和返回值交叉组合一共四种。

什么是函数式接口?

即SAM(Single Abstract Method )接口,有且只有一个抽象方法的接口(可以有默认方法或者是静态方法和从Object继承来的方法,但是抽象方法有且只能有一个)。 JDK1.8之后,添加@FunctionalInterface表示这个接口是是一个函数式接口,因为有了@functionalInterface标记,也称这样的接口为Mark(标记)类型的接口。举例子:

@FunctionalInterface
public interface Runnable {
	  public abstract void run();
}//来自源码

只有函数式接口的变量或者是函数式接口,才能够赋值为Lambda表达式。这个接口中,可以有默认方法,或者是静态方法。函数式接口中还可以有Object中覆盖的方法,也就是equals方法,hashCode方法。 JDK1.8之后,如果是函数式接口,可以添加 @FunctionalInterface表示这是一个函数式接口,举例:

@FunctionalInterface
java.lang.Runnable{
    void run();
}
	   
@FunctionalInterface
java.lang.Comparator<T>{
	int compare(T o1, T o2);
}

@FunctionalInterface
public interface Function<T, R> {
	R apply(T t);
}

针对上面的例子,比方说这个Runnable接口是支持Lambda表达式,那么如果有一个方法(比如Thread类的构造函数)需要传入一个Runnable接口的实现类的话,那么就可以直接把Lambda表达式写进去。

换个角度说TreeSet,它有一个构造函数中是要求传入一个接口类型,如果这个接口类型恰好是函数式接口,那么直接传进去一个Lambda表达式即可。

 函数式接口有什么作用?

函数式接口能够接受匿名内部类的实例化对象,换句话说,我们可以使用匿名内部类来实例化函数式接口的对象,而Lambda表达式能够代替内部类实现代码的进一步简化,因此,Lambda表达式和函数式接口紧密的联系到了一起,接下来的这句话非常的重要:

每一个Lambda表达式能隐式的给函数式接口赋值

上文中提到的例子:

new Thread(() -> System.out.println(“hello”)).start();

编译器会认为Thread()中传入的是一个Runnable的对象,而我们利用IDEA的智能感知,鼠标指向“->”或“()”的时候,会发现这是一个Runnable类型,实际上编译器会自动将Lambda表达式赋值给函数式接口,在本例中就是Runnable接口。本例中Lambda表达式将打印方法传递给了Runnable接口中的run()方法,从而形成真正的方法体。

而且,

参数与返回值是一一对应的,即如果函数式接口中的抽象方法是有返回值,有参数的,那么要求Lambda表达式也是有返回值,有参数的(余下类推)

自定义一个函数式接口:

package com.isea.java;
@FunctionalInterface
public interface IMyInterface {
    void study();
}

package com.isea.java;
public class TestIMyInterface {
    public static void main(String[] args) {
        IMyInterface iMyInterface = () -> System.out.println("I like study");
        iMyInterface.study();
    }
}//这里的Lambda表达式将方法体赋值给函数式接口

四大函数式接口:

有时候后,如果我们调用某一个方法,发现这个方法中需要传入的参数要求是一个函数式的接口,那么我们可以直接传入Lambda表达式。这些接口位于java.util.function包下,需要注意一下,java.util包和java.util.function包这两个包没有什么关系,切不可以为function包是java.util包下面的包。

1. 消费型接口:Consumer< T> void accept(T t)有参数,无返回值的抽象方法;

2. 供给型接口:Supplier < T> T get() 无参有返回值的抽象方法;

3. 断定型接口: Predicate< T> boolean test(T t):有参,但是返回值类型是固定的boolean

4. 函数型接口: Function< T,R> R apply(T t)有参有返回值的抽象方法;

除了这四个之外,在java.util.function包下还有很多函数式接口可供使用。

例子:如果薪资小于10000,涨工资到10000

package com.isea.java;
import java.util.HashMap;
public class TestLambda {
    public static void main(String[] args) {
        HashMap<String,Double> map = new HashMap<>();
        map.put("周瑜",9000.0);
        map.put("宋江",12000.0);
        map.put("张飞",8000.0);

        map.forEach((k,v) -> {
            if (v < 10000.0)
                map.put(k,10000.0);
        });//BiConsumer<T,U>,void apply(T t, U u)
        map.forEach((k,v) -> System.out.print(k + ":" + v + "\t\t"));
    }
}//结果打印:张飞:10000.0		周瑜:10000.0		宋江:12000.0		

方法引用:

当Lambda表达式满足某种条件的时候,使用方法引用,可以再次简化代码

构造引用:当Lambda表达式是通过new一个对象来完成的,那么可以使用构造引用。

package com.isea.java;
import java.util.function.Supplier;
public class TestLambda {
    public static void main(String[] args) {
//        Supplier<Student> s = () -> new Student();

        Supplier<Student> s = Student::new;
    }//实际过程:将new Student()赋值给了Supplier这个函数式接口中的那个抽象方法
}

类名::实例方法

Lambda表达式的的Lambda体也是通过一个对象的方法完成,但是调用方法的对象是Lambda表达式的参数列表中的一个,剩下的参数正好是给这个方法的实参。

package com.isea.java;
import java.util.TreeSet;
public class TestLambda {
    public static void main(String[] args) {
//        TreeSet<String> set = new TreeSet<>((s1,s2) -> s1.compareTo(s2));
/*  这里如果使用第一句话,编译器会有提示:Can be replaced with Comparator.naturalOrder,这句话告诉我们
  String已经重写了compareTo()方法,在这里写是多此一举,这里为什么这么写,是因为为了体现下面
  这句编译器的提示:Lambda can be replaced with method reference。好了,下面的这句就是改写成方法引用之后:
*/ //类名::实例方法
        TreeSet<String> set = new TreeSet<>(String::compareTo);
        set.add("Hello");
        set.add("isea_you");
       // set.forEach(t -> System.out.println(t));//Hello \n isea_you
        set.forEach(System.out::println);
        //(1)对象::实例方法,Lambda表达式的(形参列表)与实例方法的(实参列表)类型,个数是对应
    }
}

对象::实例方法

上面的代码的最后一句已经演示。

类名::静态方法

package com.isea.java;
import java.util.stream.Stream;
public class TestLambda {
    public static void main(String[] args) {
//        Stream<Double> stream = Stream.generate(() -> Math.random());
//        类名::静态方法, Lambda表达式的(形参列表)与实例方法的(实参列表)类型,个数是对应
        Stream<Double> stream = Stream.generate(Math::random);
        stream.forEach(System.out::println);
    }
}

第一次认认真真的写博客,已经凌晨两点了,18点开始编辑的,写的过程中我问自己,做这个事情有用么?几度都想放弃了,有没有用,我也不知道,但是我知道:技术的进步,循序渐进;慢下来,扎扎实实;用过度的功夫,才能理解表面肤浅的深度。

曾经,有好几份真挚美好的爱情摆在的面前,我都没有好好珍惜,直到,后来做了程序员,才后悔莫及。

    原文作者:屏占比
    原文地址: https://blog.csdn.net/qq_31807385/article/details/82670505
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞