关于java 1.8的Lambda表达式详解

最新推荐文章于 2022-04-12 20:13:40 发布

qq_39495331

最新推荐文章于 2022-04-12 20:13:40 发布

阅读量5.1k

点赞数

分类专栏： j 文章标签： j

本文链接：https://blog.csdn.net/qq_39495331/article/details/81011662

版权

j 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

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

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

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

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

然后写一个自定义类:

public class Complex{
  private int imag;
  private 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方法实现的

现在我们将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);
		}
	}
	

}