java8新特性-Lambda

最新推荐文章于 2024-06-26 21:41:42 发布

Yaml墨韵

最新推荐文章于 2024-06-26 21:41:42 发布

阅读量725

点赞数 33

分类专栏： java基础文章标签： java 开发语言 Lambda

本文链接：https://blog.csdn.net/Yaml4/article/details/136271779

版权

java基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

本文详细介绍了Java8中的Lambda表达式，包括其定义、基本语法、参数列表，以及与传统匿名内部类的对比。此外，还涵盖了函数式接口的使用、4个基础接口的应用、Lambda表达式的调用方式，如无参和有参函数、集合操作和线程调用的简化。

摘要由CSDN通过智能技术生成

2.使用@FunctionalInterface注解标记该接口为函数接口

一、Lambda

1、什么是Lambda表达式

Lambda 表达式是 Java 8 引入的一种新的语法特性，它可以使得代码更加简洁、易读，并且支持函数式编程。Lambda 表达式实际上就是一个匿名方法，它可以作为参数传递给方法或者存储在变量中。

2.Lambda表达式的基本语法：

* 1.举例： (o1,o2) -> Integer.compare(o1,o2);
* 2.格式：
* -> :lambda操作符或箭头操作符
* ->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表
* ->右边：lambda体（其实就是重写的抽象方法的方法体

3.参数列表

4.Lambda表达式使用前后对比

举例一：

@Test
public void test1(){

    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("我爱北京天安门");
        }
    };

    r1.run();

    System.out.println("***********************");

    Runnable r2 = () -> System.out.println("我爱北京故宫");

    r2.run();
}

举例二：

@Test
public void test2(){

    Comparator<Integer> com1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1,o2);
        }
    };

    int compare1 = com1.compare(12,21);
    System.out.println(compare1);

    System.out.println("***********************");
    //Lambda表达式的写法
    Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);

    int compare2 = com2.compare(32,21);
    System.out.println(compare2);


    System.out.println("***********************");
    //方法引用
    Comparator<Integer> com3 = Integer :: compare;

    int compare3 = com3.compare(32,21);
    System.out.println(compare3);
}

二、函数式接口

1.函数式接口的使用说明

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。

我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。

Lambda 表达式的函数体可以是一个表达式，也可以是一个语句块。如果函数体只有一条表达式，可以直接写在箭头后面；如果函数体包含多条语句，需要使用大括号 {} 将它们括起来，并使用分号 ; 分隔。

Lambda表达式的本质：作为函数式接口的实例

2.4个基本的函数式接口

Java8中关于Lambda表达式提供的4个基本的函数式接口：具体使用：

3.如何定义函数接口

定义一个函数接口需要满足以下两点：

1.保证接口中只能有一个抽象方法

2.使用@FunctionalInterface注解标记该接口为函数接口

@FunctionalInterface
public interface MyInterfaceByJava8 {
	
    void add();//只能存在一个抽象方法
}

4.Lambda表达式调用方式

1.使用Lambda调用无参函数

首先定义一个函数接口

@FunctionalInterface
public interface FuncInterface {
	void add();
}

接着实现并调用这个无参函数，这里展示传统的匿名内部类调用法，跟Lambda调用法。

public static void main(String [] args){
	//使用匿名内部类调用
	new FuncInterface(){
			
	    @Override
		public void add() {
			System.out.println("匿名内部类实现调用");
		}
			
	}.add();
		
	//使用Lambda调用
	((FuncInterface)()->{System.out.println("Lambda实现调用");}).add();
		
}

可以看到使用Lambda代码更加简洁优雅

2.使用Lambda调用有参函数

定义函数接口

@FunctionalInterface
public interface FuncInterface2 {
	int del(int id);
}

实现并调用

public static void main(String [] args){
		
		int id=101;
		//使用匿名内部类调用
		int result1=new FuncInterface2(){
 
			@Override
			public int del(int id) {
				System.out.println("匿名内部类实现调用:"+id);
				return 1;
			}
			
		}.del(id);
			
		//使用Lambda调用
		int result2=((FuncInterface2)(p)->{System.out.println("Lambda实现调用:"+p);return 1;}).del(id);
		
		
		System.out.println(result1);
		System.out.println(result2);
		
}

3.使用Lambda的精简写法

当函数参数仅有一个时可以省略括号（没有参数时必须用空括号，不能省）

//普通写法
int result2=((FuncInterface2)(p)->{System.out.println("Lambda实现调用:"+p);return 1;}).del(id);
 
//精简写法--省略参数园括号
int result2=((FuncInterface2)p->{System.out.println("Lambda实现调用:"+p);return 1;}).del(id);

当函数体只有一条语句可以省略{}

//普通写法
((FuncInterface)()->{System.out.println("Lambda实现调用");}).add();
 
//精简写法--省略函数体括号
((FuncInterface)()->System.out.println("Lambda实现调用")).add();

当函数体仅有一条语句且是返回语句时，可以省略return

//普通写法
int result2=((FuncInterface2)p->return 1).del(id);
 
//精简写法--省略return
int result2=((FuncInterface2)p->1).del(id);

4.使用Lambda实现集合遍历

public static void main(String [] args){
		List<String> names=Arrays.asList("小明","小黑","小红");
		
		//传统遍历--增强for
		for(String name:names){
			System.out.println(name);
		}
		
		//传统遍历--匿名内部类
		names.forEach(new Consumer<String>(){
 
			@Override
			public void accept(String name) {
				System.out.println(name);
			}
			
		});
		
		//Lambda表达式遍历
		names.forEach(name->System.out.println(name));
}

5.使用Lambda实现集合排序

将学生集合的学生按照年龄排序

public static void main(String [] args){
		List<Student> students1=Arrays.asList(new Student("小明",18),new Student("小黑",16),new Student("小红",17));
		List<Student> students2=Arrays.asList(new Student("小明",18),new Student("小黑",16),new Student("小红",17));
		//传统排序--匿名内部类
		students1.sort(new Comparator<Student>(){
 
			@Override
			public int compare(Student stu1, Student stu2) {
				return stu1.getAge()- stu2.getAge();
			}});
 
		//Lambda
		students2.sort((stu1,stu2)->stu1.getAge()-stu2.getAge());//省略return
		
		System.out.println(students1);
		System.out.println(students2);
}

6.使用Lambda实现线程调用

public static void main(String [] args){
		//传统调用
		new Thread(new Runnable(){
 
			@Override
			public void run() {
				System.out.println("子线程运行了");
			}
			
		}).start();
		
		//Lambda
		new Thread(()->System.out.println("子线程运行了")).start();
}