JDK8->Lambda表达式，四个Demo了解一下

Bertha 。 2022-01-28 22:29 427阅读 0赞

半路出家程序猿 2019-05-17 11:39:52

# Java1.8新增了Lambda表达式，目的是为了方便匿名内部类的使用。 #

我们先看一个例子：向集合中增加一些系定义的类对象并筛选符合条件的对象进行打印输出

先编写一个接口：里面定义一个方法用来筛选符合条件的对象

public interface ComplexChecker{
     public abstract boolean check(Complex c);
     }

然后写一个自定义类:

public class Complex{
    
     public int imag;
     public int real;
    
     public Complex(int imag ,int real){
     this.imag = imag;
     this.real = real;
     }
    
     @Override
     public String toString(){
     return "imag="+this.imag+"real="+this.real;
     }
     }

现在，我们写一个类，在里面写上主方法：创建一个集合后循环向集合里添加Complex类的对象，每个对象的imag值和real值都是0-1000随机的，然后我们将集合中的对象imag的值大于200并且real的值大于400的对象筛选出来；

public class ComplexTest {
     public static void main(String[] args) {
     List<Complex> list = new ArrayList<>();
     Random random = new Random();
     //向集合添加50个Complex对象
     for(int i = 0 ; i < 50 ; i++)
     {
     list.add(new Complex(random.nextInt(1000), random.nextInt(1000)));
     }
     //然后我们将集合中imag大于200和real值大于400的对象筛选打印输出
     //首先要定义一个匿名内部类来实现ComplexChecker接口中的check（）方法
     ComplexChecker checker = new ComplexChecker() {
     @Override
     public boolean check(Complex c) {
     return c.imag>200 && c.real>400;
     }
     };
     show(list,checker);
     }
     public static void show(List<Complex> lists ,ComplexChecker checker)
     {
     for (Complex com: lists) {
     if(checker.check(com))
     System.out.println(com);
     }
     }
     }

运行结果：将集合中所有 imag > 200 、 real > 400的集合元素筛选打印出来

imag=402real=553
     imag=726real=565
     imag=666real=899
     imag=261real=738
     imag=923real=702
     imag=270real=851
     imag=996real=516
     imag=232real=890
     imag=415real=988
     imag=210real=482
     imag=366real=650
     imag=737real=844
     imag=874real=980
     imag=875real=607
     imag=593real=651
     imag=580real=752
     imag=899real=984
     imag=253real=880
     imag=783real=452
     imag=360real=910
     imag=816real=779
     imag=688real=984

**以上是直接使用匿名内部类并重写check方法实现的**

# Lambda表达式 #

**现在我们将ComplexTest类的代码稍作修改：**

import java.util.ArrayList;
     import java.util.List;
     import java.util.Random;
     public class ComplexTest {
     public static void main(String[] args) {
     List<Complex> list = new ArrayList<>();
     Random random = new Random();
     //向集合添加50个Complex对象
     for(int i = 0 ; i < 50 ; i++)
     {
     list.add(new Complex(random.nextInt(1000), random.nextInt(1000)));
     }
     //然后我们将集合中imag大于200和real值大于400的对象筛选打印输出
     //首先要定义一个匿名内部类来实现ComplexChecker接口中的check（）方法
     // ComplexChecker checker = new ComplexChecker() {
     // 
     // @Override
     // public boolean check(Complex c) {
     // return c.imag>200 && c.real>400;
     // }
     // };
     // 
     // show(list,checker);
     show(list, c->c.imag>200 && c.real>400);
     }
     public static void show(List<Complex> lists ,ComplexChecker checker)
     {
     for (Complex com: lists) {
     if(checker.check(com))
     System.out.println(com);
     }
     }
     }

备注是的代码就是被修改的代码；

我们直接使用Lambda表达式代入show()方法中来实现匿名内部类的简写：

**show(list, c->c.imag>200 && c.real>400);**

其中 c 就是check方法中的参数，当参数是一个的时候可以省略括号，参数不为一个的时候就需要将参数用小括号括起来：**（参数1，参数2，....）->\{函数体\}，当没有参数的时候就写成()->\{函数体\}；jdk会根据上下文判断c的类型，在这里它是Complex类的对象引用，然后->后面跟上你的函数体，如果函数体有多行代码，则需要用“\{”和“\}”将代码括起来，我这里只有一句话：c.imag>200 && c.real>400，所以大括号可以省略掉。**

# **需要注意的是Lambda表达式只能用于函数式接口，什么是函数式接口呢？** #

只有一个抽象方法的接口就是函数接口。

**一. 也可以不用接口，在你的ComplexTest类中添加静态check方法，修改ComplexTest类**

import java.util.ArrayList;
     import java.util.List;
     import java.util.Random;
     public class ComplexTest {
     public static void main(String[] args) {
     List<Complex> list = new ArrayList<>();
     Random random = new Random();
     //向集合添加50个Complex对象
     for(int i = 0 ; i < 50 ; i++)
     {
     list.add(new Complex(random.nextInt(1000), random.nextInt(1000)));
     }
     //然后我们将集合中imag大于200和real值大于400的对象筛选打印输出
     //首先要定义一个匿名内部类来实现ComplexChecker接口中的check（）方法
     // ComplexChecker checker = new ComplexChecker() {
     // 
     // @Override
     // public boolean check(Complex c) {
     // return c.imag>200 && c.real>400;
     // }
     // };
     // 
     // show(list,checker); //使用匿名内部类的格式
     // show(list, c->c.imag>200 && c.real>400); //使用Lambda表达式实现接口check方法
     show(list ,ComplexTest::check); //放弃接口使用，直接在本类写静态方法并调用
     }
     public static boolean check(Complex c)
     {
     return c.imag > 200 && c.real > 400;
     }
     public static void show(List<Complex> lists ,ComplexChecker checker)
     {
     for (Complex com: lists) {
     if(checker.check(com))
     System.out.println(com);
     }
     }
     }

**二.在ComplexTest类中添加成员check方法，修改ComplexTest类**

import java.util.ArrayList;
     import java.util.List;
     import java.util.Random;
     public class ComplexTest {
     public static void main(String[] args) {
     List<Complex> list = new ArrayList<>();
     Random random = new Random();
     //向集合添加50个Complex对象
     for(int i = 0 ; i < 50 ; i++)
     {
     list.add(new Complex(random.nextInt(1000), random.nextInt(1000)));
     }
     //然后我们将集合中imag大于200和real值大于400的对象筛选打印输出
     //首先要定义一个匿名内部类来实现ComplexChecker接口中的check（）方法
     // ComplexChecker checker = new ComplexChecker() {
     // 
     // @Override
     // public boolean check(Complex c) {
     // return c.imag>200 && c.real>400;
     // }
     // };
     // 
     // show(list,checker); //使用匿名内部类的格式
     // show(list, c->c.imag>200 && c.real>400); //使用Lambda表达式实现接口check方法
     ComplexTest complexTest = new ComplexTest();
     show(list ,complexTest::check); //放弃接口使用，直接在本类写成员方法并调用
     }
     public boolean check(Complex c)
     {
     return c.imag > 200 && c.real > 400;
     }
     public static void show(List<Complex> lists ,ComplexChecker checker)
     {
     for (Complex com: lists) {
     if(checker.check(com))
     System.out.println(com);
     }
     }
     }

**三.引用集合对象类中的方法，可以把check方法写到集合类中（Complex类）**

**修改Complex类和ComplexTest类**

public class Complex{
     public int imag;
     public int real;
     public Complex(int imag ,int real)
     {
     this.imag = imag;
     this.real = real;
     }
     public boolean check()
     {
     return imag > 200 && real > 400;
     }
     @Override
     public String toString()
     {
     return "imag="+this.imag+"real="+this.real;
     }
     }

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

import java.util.ArrayList;
     import java.util.List;
     import java.util.Random;
     public class ComplexTest {
     public static void main(String[] args) {
     List<Complex> list = new ArrayList<>();
     Random random = new Random();
     //向集合添加50个Complex对象
     for(int i = 0 ; i < 50 ; i++)
     {
     list.add(new Complex(random.nextInt(1000), random.nextInt(1000)));
     }
     //然后我们将集合中imag大于200和real值大于400的对象筛选打印输出
     //首先要定义一个匿名内部类来实现ComplexChecker接口中的check（）方法
     // ComplexChecker checker = new ComplexChecker() {
     // 
     // @Override
     // public boolean check(Complex c) {
     // return c.imag>200 && c.real>400;
     // }
     // };
     // 
     // show(list,checker); //使用匿名内部类的格式
     // show(list, c->c.imag>200 && c.real>400); //使用Lambda表达式实现接口check方法
     // ComplexTest complexTest = new ComplexTest();
     // show(list ,complexTest::check); //放弃接口使用，直接在本类写静态方法并调用
     show(list, h->h.check());
     }
     public boolean check(Complex c)
     {
     return c.imag > 200 && c.real > 400;
     }
     public static void show(List<Complex> lists ,ComplexChecker checker)
     {
     for (Complex com: lists) {
     if(checker.check(com))
     System.out.println(com);
     }
     }
     }

# 最精髓 #

由一开始的

![【java】JDK8->Lambda表达式，四个Demo了解一下。][java_JDK8-_Lambda_Demo]

精简到

![【java】JDK8->Lambda表达式，四个Demo了解一下。][java_JDK8-_Lambda_Demo 1]

最精简

![【java】JDK8->Lambda表达式，四个Demo了解一下。][java_JDK8-_Lambda_Demo 2]

(参考CSDN作者：qq\_394953\*案例)

[java_JDK8-_Lambda_Demo]: http://p1.pstatp.com/large/pgc-image/fce50487bf214b9e85b306dc7494569a
[java_JDK8-_Lambda_Demo 1]: http://p1.pstatp.com/large/pgc-image/41cc68cd76f44c4ea41d591f8a7c0733
[java_JDK8-_Lambda_Demo 2]: http://p1.pstatp.com/large/pgc-image/c4a1c25a07f145798397adb5988a1a8b