Java基础复习（七） Lambda表达式

最新推荐文章于 2023-06-12 17:00:41 发布

Beacon-Fire

最新推荐文章于 2023-06-12 17:00:41 发布

阅读量167

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_39446291/article/details/97885439

版权

Java基础专栏收录该内容

19 篇文章 0 订阅

订阅专栏

Java基础复习（七）

Lambda表达式

lambda表达式:是Java8中的新特性
Java8中引入Lambda表达式，使得java可以函数式编程，在并发性能上迈出了实质性的一步。

函数式编程:（英语：functional programming）或称函数程序设计，又称泛函编程，是一种编程范型，
它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重要的基础
是λ演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（引数）和输出（传出值）

比较lambda表达式和匿名内部类:

总结:lambda表达式就是简单的匿名内部类

1.匿名内部类可以为任意接口创建实例,不管接口包含多少个抽象方法,只要匿名内部类实现所有的抽象方法
即可; 但Lambda表达式只能为函数式接口创建实例(即只能有一个抽象方法)
2.匿名内部类可以为抽象类甚至是普通类创建实例;但Lambda表达式只能为函数式接口创建实例
3.匿名内部类实现的抽象方法的方法体允许调用接口中定义的默认(default)方法;但Lambda表达式的代码块
不允许调用接口中的默认(default)方法

代码实例

  package lambda;
  
  interface InterfaceA{
      public void show();
  }
  public class demo1 {
      public static void main(String[] args) {
          InterfaceA a = new InterfaceA() {
              @Override
              public void show() {
                  System.out.println("匿名内部类的show");
              }
              public void eat(){
                  System.out.println("匿名内部类的eat");
              }
          };
          a.show();
  
          //通过lambda表达式
          InterfaceA b = ()->{
              System.out.println("lambda的show");
          };
          b.show();
  
          //简化
          InterfaceA bb = ()-> System.out.println("简化的lambda表达式的show");
          bb.show();
      }
  }

基本语法

（参数）->表达式或（参数）->{方法体;};

1.形参列表:

形参列表允许省略形参类型,若形参列表中只有一个参数,形参列表的圆括号也可以省略代码
```
//1.没有参数的
		InterA a = ()->{
			System.out.println("没有参数");
		};
		a.showA();
		//简化
		InterA aa = ()->System.out.println("没有参数");
		aa.showA();
		//2.一个参数的
		InterB b = (ib)->{
			System.out.println("一个参数:"+ib);
		};
		b.showB(4);
		//简化
		InterB bb = (ib)->System.out.println("一个参数:"+ib);
		bb.showB(5);
		//3.两个参数的
		InterC c = (ia,ib)->{
			int sum = ia+ib;
			System.out.println("两个参数:"+" ia:"+ia+"   ib:"+ib+"    sum:"+sum);
		};
		c.showC(4, 6);
		//简化
		InterC cc = (ia,ib)->System.out.println("两个参数:"+" ia:"+ia+"   ib:"+ib);
		cc.showC(4, 5);
```
2.箭头(->)

必须通过英文的划线号和大于符号组成

3.代码块:

如果代码块只包含一条语句,lambda表达式允许省略代码块的花括号,那么这条语句就不要用花括号表示语句结束

4.返回值:

lambda代码块只有一条return语句,甚至可以省略return关键字

lambda表达式需要返回值,而它的代码块中仅有一条省略了return的语句,lambda表达式会自动返回这条语句的结果
```
InterD d = (i,j)->{
			int sum = i+j;
			return sum;
		};
		int value = d.showD(4, 6);
		System.out.println(value);
		//简化  简化版的不需要写return 
		InterD dd = (i,j)->i+j;
		int value1 = dd.showD(4, 7);
		System.out.println(value1);
```
5.lambda表达式可以直接作为函数的参数

当要实现只有一个接口的抽象函数时，使用lambda表达式能够更灵活。
```
//5.lambda表达式作为参数
		fun2(
				new InterC() {public void showC(int a, int b) {}}
			);
		fun2((i,j)->System.out.println("lambda表达式作为参数"+" i:"+i));
public static void fun2(InterC c) {
		c.showC(4, 6);
	}
```
6.lambda表达式类型

Lambda表达式的类型,也被称为"目标类型(target type)",Lambda表达式的目标类型必须是"函数式接口(functional interface)"
Java8新引入的概念,函数接口（functional interface）。它的定义是：一个接口，如果只有一个显式声明的抽象方法，那么它就是一个函数接口。一般用@FunctionalInterface标注出来 (也可以不标记),函数式接口可以包含多个default或static方法,但是只能声明一个抽象方法@FuctionalInterface主要作用就是检查当前接口是不是函数接口若想使用lambdaname目标必须是一个函数接口

7.lambda表达式中变量的使用

如果是全局的变量直接用.如果是局部变量会被默认在前面添加final(被作为常量,类似于局部变量在局部内部类中使用的情况)
```
String value11 = "hello world";
		InterA aaa = ()->{
			System.out.println(value11);
			//value11是final类型的是一个常量,值是不能改变的
			//value11 = "haha";
		};
		aaa.showA();
```

方法引用于构造器引用

引用类方法
引用特定对象的实例方法
引用某类对象的实例方法
引用构造方法

代码实例

public class Demo3 {
	public static void main(String[] args) {
//		 * 1.引用类方法
		Test1.fun1();
//		 * 2.引用特定对象的实例方法
		Test2.fun2();
//		 * 3.引用某类对象的实例方法
		Test3.fun3();
//		 * 4.引用构造方法
		Test4.fun4();
	}
}
//* 1.引用类方法
interface Converter{
	//将字符串转换成整数
	Integer convert(String value);
}
class Test1{
	public static void fun1() {
		//原来的方法
		Converter converter = value->Integer.valueOf(value);
		Integer v1 = converter.convert("222");
		System.out.println(v1);
		
		//简化
		//引用类方法
		//通过::实现,这里会自动将lambda表达式方法的参数全部传递给当前的方法
		Converter converter2 = Integer::valueOf;
		Integer v2 = converter2.convert("333");
		System.out.println(v2);
	}
}
//* 2.引用特定对象的实例方法
interface IA{
	public void show(String message);
}
class A{
	public void play(String i) {
		System.out.println("这里是A的方法play"+"  i:"+i);
	}
}
class Test2{
	public static void fun2() {
		//原来
		IA ia = message->new A().play(message);
		ia.show("hello");
		//简化
		IA ia2 = new A()::play;
		ia2.show("world");
	}
}
//* 3.引用某类对象的实例方法
interface IB{
	String subString(String string,int stat,int end);
}
class Test3{
	public static void fun3() {
		//原来
		IB ib = (string,stat,end)->string.substring(stat, end);
		String sub1 = ib.subString("hello world", 2, 4);
		System.out.println(sub1);
		//简化
		 //函数式接口中被实现方法的第一个参数作为调用者,后面的参数全部传递给该方法
		IB ib2 = String::substring;
		String sub2 = ib2.subString("class is over", 2, 5);
		System.out.println(sub2);
	}
}
//* 4.引用构造方法
interface IC{
	Object show(String name,int age);
}
class Person{
	String name;
	int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

}
class Test4{
	public static void fun4() {
		IC ic = (name,age)->new Person(name, age);
		Object per = ic.show("bing", 19);
		System.out.println(per);
		
		//简化 
		//构造方法引用代替lambda表达式,函数式接口中被实现方法的全部参数传该构造方法作为参数
		IC ic2 = Person::new;
		Object per1 = ic2.show("chen", 10);
		System.out.println(per1);
	}
}

Beacon-Fire

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础复习（七） Lambda表达式

Java基础复习（七）Lambda表达式lambda表达式:是Java8中的新特性Java8中引入Lambda表达式，使得java可以函数式编程，在并发性能上迈出了实质性的一步。函数式编程:（英语：functional programming）或称函数程序设计，又称泛函编程，是一种编程范型，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重...
复制链接

扫一扫