Java8-Lambda表达式

最新推荐文章于 2022-08-28 17:02:58 发布
最新推荐文章于 2022-08-28 17:02:58 发布
阅读量239 收藏
点赞数
分类专栏： Java 文章标签： lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40867650/article/details/109277183
版权

1、Lambda表达式的概念

  • Lambda表达式时Java8中值得学习的新特性之一。
  • Lambda表达式从本质上来说是一个匿名方法，使用这个匿名方法来实现接口中的方法，方便简洁，简化代码。

2、Lambda表达式的使用场景

Lambda表达式最大的优点就是实现接口时大大的简化了代码。

//创建一个接口
package cn;

public interface Human {

    public int test(int a);

}

//================3种实现方法==================================
package cn.Impl;

import cn.Human;

public class Program {

    public static void main(String[] args){
        //1、显示实现类对象
        Human student1 = new Student();
    }

    private static class Student implements Human{

        @Override
        public int test(int a) {
            return a*a;
        }
    }

    //2、使用匿名内部类实现
    Human student2 = new Human() {
        @Override
        public int test(int a) {
            return a*a;
        }
    };


    //3、使用Lambda表达式实现
    Human student3 = a -> a * a;
}

3、Lambda表达式对接口的要求

  • 并不是所有的接口都可以使用Lambda表达式，毕竟Lambda表达式本质上来说只是一个匿名方法，只有当接口当中必须要实现的方法有且仅有一个，才能用Lambda表达式实现。
  • Lambda表达式只能用来实现函数式接口。

4、函数式接口

4.1 基础概念

定义 ：

  • 在一个接口中，要求实现类必须实现的方法，有且仅有一个，这样的接口，称为函数式接口 。
//Test1接口中只有一个需要被实现的方法，所以Test1是一个函数式接口
interface Test1{
	void test1();
}

//Test2接口中有大于1的方法需要被现实，所以Test2不是一个函数式接口
interface Test2{
	void test2();
	void test3();
}

//Test3接口中没有方法需要被实现，所以Test3不是一个函数式接口
interface Test3{

}

//Test4接口虽然没有定义方法，但是可以从父接口Test1中继承一个抽象方法，所以Test4也是一个函数式接口
interface Test4 extends Test1{
}

//Test5中虽然有两个方法，但是default修饰的方法不是子类必须要实现的，所以必须要实现的方法只有一个，Test5也是个函数式接口
interface Test5{
	void test5();
	default void test();
}

//Test6接口中的toString方法时Object类中定义的
//在实现类实现接口中的方法的时候，toString可以不重写！因为可以从父类Object中继承到
//此时，Test6接口中必须实现的方法只有一个，所以Test6也是一个函数式接口
interface Test6{
	void test6();
	String toString();
}
4.2 @FunctionalInterface
  • 此注解用在接口之前，，可以判断接口是否是 一个函数式接口。
  • 如果是一个函数式接口，没有任何问题，如果不是一个函数式接口，则会报错。功能类似于@Override
@FunctionalInterface
interface FunctionalInterface{
	void test();
}

5、Lambda表达式的基础语法

  • Lambda表达式本质上是一个匿名函数，因此我们写Lambda表达式的时候不需要关心方法名和返回值类型，只需关注两个地方即可：参数列表 和 方法体

基础语法：

(参数) -> {
	方法体
}
  • 参数列表：要求和实现的接口中的方法参数一致，包括数量和类型
  • 方法体：如果接口定义有返回值，那么在实现的时候，注意返回值的返回。
  • ->:分隔参数部分和方法体部分
//基础语法示例：
//定义多个函数式接口
//1、无参数无返回值
public interface NoneReturnNoneParamter {
    void test();
}
//2、有一个参数无返回值
public interface NoneReturnSingleParamter {
    void test(int a);
}
//3、有多个参数无返回值
public interface NoneReturnMultipleParamter {
    void test(int a, int b,int c);
}
//4、无参数有返回值
public interface SingleReturnNoneParamter {
    int test();
}
//5、有一个参数有返回值
public interface SingleReturnSingleParamter {
    int test(int a);
}
//6、有多个参数有返回值
public interface SingleReturnMultipleParamter {
    int test(int a,int b,int c);
}

//=======================Lambda表达式实现==================================

public class BasicSyntax {

    public static void main(String[] args){
        //1、实现无参无返回值的函数式接口方法
        NoneReturnNoneParamter Lambda1 = () -> {
            System.out.println("这是一个无参无返回值的方法");
        };
        Lambda1.test();

        //2、实现有一个参数无返回值的函数式接口方法
        NoneReturnSingleParamter Lambda2 = (int a) -> {
            System.out.println("这是一个只有一个参数无返回值的方法，参数a的值=" + a);
        };
        Lambda2.test(6);

        //3、实现多个参数无返回值的函数式接口方法
        NoneReturnMultipleParamter Lambda3 = (int a, int b, int c) ->{
            System.out.println("这是一个多个参数无返回值的方法，参数abc的值分别为："+ a + "," + b + "," + c);
        };

        Lambda3.test(10,20,30);

        //4、实现无参数有返回值的函数式接口方法
        SingleReturnNoneParamter Lambda4 = () -> {
          int a = 2;
          return a;
        };

        System.out.println("这是一个无参数有返回值的方法，返回值为："+ Lambda4.test());

        //5、实现有一个参数有返回值的函数式接口方法
        SingleReturnSingleParamter Lambda5 = (int a) -> {
            return a*a;
        };

        System.out.println("这是有一个参数有返回值的方法，参数的平方为：" + Lambda5.test(6));

        //6、实现有多个参数有返回值的函数式接口方法
        SingleReturnMultipleParamter Lambda6 = (int a,int b,int c) ->{
            return a*b*c;
        };

        System.out.println("这是有多个参数有返回值的方法，参数相乘结果为：" + Lambda6.test(10,20,30));
    }


}

6、Lambda表达式语法进阶

  • 上述代码中，确实使用了Lambda表达式实现接口，但是还可以再精简一些
6.1 参数部分省略
  • 由于在接口的方法中，已经定义了参数的类型，而且在使用Lambda表达式实现接口的时候，必须保证参数数量和参数类型与接口中的方法保持一致，因此在使用Lambda表达式的时候参数的类型可以不用写。
  • 需要注意的是，参数类型如果需要省略，要么全部省略，要么全部不要省略，不要出现有的省略有的不省略的情况。
  • 如果参数列表的参数仅且只有一个，小括号可以省略
//参数类型可以不用写
SingleReturnSingleParamter Lambda5 = (a) -> {a
            return a*a;
        };
//如果参数列表的参数仅且只有一个，小括号可以省略
SingleReturnSingleParamter Lambda5 = a -> {a
            return a*a;
        };
6.2 方法体部分省略
  • 如果说方法体中的代码有且只有一句，那么方法体的大括号可以省略
  • 在方法体中的代码有且只有一句的前提下，如果方法有返回值，那么return也要一起省略
SingleReturnSingleParamter Lambda5 = a -> {
            return a*a;
        };
//省略为以下
SingleReturnSingleParamter Lambda5 = a -> a*a;

7、函数引用

  • Lambda表达式的诞生是为了简化接口实现，所以在其表达式中是不应该出现比较复杂的逻辑的，不然会对程序造成很大的影响，如果处理的逻辑比较复杂，一般会单独写一个方法实现，然后在Lambda表达式中引用。
  • 引用一个已经存在的方法，使其代替Lambda表达式完成接口的实现
7.1 静态方法的引用

语法：

  • 类::静态方法名

注意事项：

  • 在引用的方法后面，不要加小括号
  • 引用的这个方法，参数的类型和数量、返回值，必须和接口定义的一致
package cn.Impl;

public class Test {

    private interface Calculate{
        int calculate(int a,int b);
    }

    public static void main(String[] args) {
       	//Calculate calculate = (a,b) -> calculate(a,b);
        //静态函数引用 类::静态方法名 （后面不用加括号）
        Calculate calculate = Test::calculate;
        System.out.println(calculate.calculate(20,20));
    }

    //以下方法的参数类型数量和返回值必须和接口定义的方法保持一致
    private static int calculate(int x,int y){
        if (x > y) return x-y;
        else if (x < y) return y-x;
        return x+y;
    }
}
7.2 非静态方法的引用

语法：

  • new 对象::非静态方法名

注意事项：

  • 非静态方法对象需要new出来
  • 在引用的方法后面，不要加小括号
  • 引用的这个方法，参数的类型和数量、返回值，必须和接口定义的一致
package cn.Impl;

public class Test {

    private interface Calculate{

        int calculate(int a,int b);

    }

    public static void main(String[] args) {
        //引用一个非静态方法
        Calculate calculate = new Test()::calculate2;
        System.out.println(calculate.calculate(10,20));
    }


    private int calculate2(int x,int y){
        if (x > y) return x*x;
        else if (x < y) return y*y;
        return x+y;
    }
}
7.3 构造方法的引用

语法：

  • 类名::new

注意事项：

  • 可以通过接口中的方法参数，区分引用不同的构造方法
  • 被引用构造方法的类中一定要有对应参数的构造方法才可以被引用，否则将会报错

8、对象方法的特殊引用

  • 如果使用Lambda表达式实现接口的时候，接口方法参数中包含了某一个对象，Lambda表达式中可以直接使用这个对象并调用其中的方法来实现整体逻辑。
public class Person{
	private String name;
	
	public void setName(String name){
		this.name = name;
	}
 	public String getName(){
 		return name;
 	}
}

//参数中有对象
interface Inf{
	//String get(Person person);
	String set(Person person,String name);
}

public class Test{
	public static void main(String[] args){
		Person person = new Person();
		person.setName("小明");
		//直接调用
		//Inf inf = Person::getName;
		Inf inf = Person::setName;
		
		//System.out.println(inf.get(person));
		inf.set(person,"小红");
		System.out.println(person.getName());
	}
}

9、Lambda表达式注意事项

  • 一个局部变量被Lambda表达式引用后，会默认修改为final类型，变量值将无法改变
JoeyChanYC
关注
专栏目录
java8-lambda表达式的基础使用.pdf
07-05
Java 8 中 Lambda 表达式的基础使用 Java 8 中的 Lambda 表达式是 Java 8 中最流行最常用的功能特性之一。它将函数式编程概念引入 Java，函数式编程的好处在于可以帮助我们节省大量的代码，非常方便易用，能够大...
利用Lambda实现通过getter/setter方法引用拿到属性名
ZERO
10-10 1872
转载自：https://blog.csdn.net/cradle2006/article/details/95073133 很多开发场景需要用到Java Bean的属性名，直接写死属性名字符串的形式容易产生bug（属性名一旦变化，IDE不会告诉你你的字符串需要同步修改）。JDK8的Lambda可以通过方法引用简化代码，同样也可以通过getter/setter的方法引用拿到属性名，避免潜在的bug。 期望实现效果 // 传统方式：hard code写死属性名 // String ITEM_NAME = "or
java lambda常用api
码眼的博客
10-14 489
1、循环遍历 和普通for循环一样，如果在循环内部没有通讯相关的耗时操作，建议使用原始的for循环。 lists.stream().forEach(l->{ System.out.println(l); }); Map<String,String> map = new HashMap<>(); map.forEach((k,...
java8中的lambda表达式，看这篇就够了
不会骑摩托的程序员不是好的摄影师
07-07 1万+
Lambda表达式 Lambda是简洁的标识可传递匿名函数的一种方式。“互动”事件驱动下，最终面向对象编程和函数式编程结合才是趋势。 java中，一段代码的传递并不容易。因为JAVA是面向对象的语言，如果要传递一段代码，必须先构建类，再生成对应的对象来传递所要的代码。在之前，JAVA的设计者都抗拒加入这一特性，虽然JAVA现有的特性也能通过类和对象实现类似的API但是这样复杂且不易于使用。在后期，问题早已不是JAVA是不是要变成一门使用函数式编程的语言，而是如何实现这种改变。在java8之前已经有了多年的实
编写Lambda表达式作为方法引用
weixin_44431458的博客
10-14 257
编写Lambda表达式作为方法引用 您看到，lambda表达式实际上是方法的实现:函数式接口的唯一抽象方法。有时人们称这些lambda表达式为“匿名方法”，因为它只是:一个没有名称的方法，你可以在应用程序中传递，存储在一个字段或变量中，作为参数传递给一个方法或构造函数，并从一个方法返回。 有时你会编写lambda表达式，只是调用在其他地方定义的特定方法。事实上，当你写下面的代码时，你已经做到了: Consumer<String> printer = s -> System.out.prin
Java Lambda表达式入门
weixin_34357436的博客
04-27 6156
原文链接:Start Using Java Lambda Expressions 下载示例程序 Examples.zip 。 原文日期: 2014年4月16日 翻译日期: 2014年4月27日 翻译人员: 铁锚 简介 (译者注:虽然看着很先进，其实Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。本人...
Java 8 lambda表达式
06-27
Java 8 的引入，尤其是Lambda表达式，对Java语言产生了深远的影响，它为Java开发者带来了更简洁、更灵活的编程方式。Lambda表达式是函数式编程的核心元素，它允许我们将函数作为方法参数传递，或者将代码块当作数据...
Java8之lambda表达式基本语法
08-29
Java8之lambda表达式基本语法 Java8中引入的lambda表达式是一种非常强大的语言特性，它可以使我们的代码变得更加简洁、灵活和高效。lambda表达式可以看作是一个匿名函数，可以作为参数传递给方法，也可以直接作为...
Java8中的 Lambda表达式教程
08-31
Java 8 中的 Lambda 表达式是一种强大的编程特性，它...通过这些特性，Java 8的Lambda表达式让代码更加简洁、易读，特别是在处理高阶函数和函数式编程场景时。理解和熟练使用Lambda表达式是提升Java 8开发效率的关键。
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
java8之lambda表达式
热门推荐
xiaoye的博客
05-25 2万+
java8已发布四年之久，但是一直没研究java8的相关新特性，前几天有点闲，就学习了java8的新特性之一lambda表达式，下面就按照我的理解讲讲一些用法。 刚开始使用lambda表达式的时候，感觉不习惯，但是使用了以后发现还是很好用的，简洁，明了，代码少 lambda表达式的语法格式如下： (parameters) -> expression或(parameters) -&...
JAVA8新特性 lambada详解：
weixin_44750143的博客
05-27 758
一：概念 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 使用 Lambda 表达式可以使代码变的更加简洁紧凑。 二：函数式编程思想 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。 做什么，而不是怎么做 我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将
JAVA8 lambda表达式操作集合
qq_42273232的博客
07-31 286
JAVA8 lambda表达式操作集合 import com.alibaba.fastjson.JSONObject; import com.google.common.collect.Lists; import org.apache.commons.lang3.builder.ToStringBuilder; import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.M
【Java基础系列教程】第二十四章 JDK8新特性_Lambda表达式、函数式接口、方法引用和构造器引用
波哩个波的博客
03-22 594
一、Lambda 表达式 二、函数式接口 三、方法引用和构造器引用
java8中 lambda表达式，stream操作
qq_45515347的博客
08-28 673
lambda 和 stream
Java Lambda详解
weixin_68320784的博客
03-31 2万+
Lambda表达式是JDK 8开始后的一种新语法形式。 作用：简化匿名内部类的代码写法 简化格式 (匿名内部类被重写方法的形参列表) -> { 重写方法 } Lambda表达式只能简化函数式接口的匿名内部类的写法形式 什么是函数式接口？ 首先必须是接口、其次接口中有且仅有一个抽象方法的形式 通常会在接口上加上一个@FunctionalInterface注解，标记该接口必须是满足函数式接口 如何使用Lambda？ 我们将根据下面三个问题来帮助大家理解和使用Lambda 背景：我们自
【Java】函数式接口基础概念
分享记录开发中的问题，欢迎一起探讨！
06-09 163
如果说，一个接口必须实现的抽象方法有且只有一个的话，那么这个接口就是函数式接口。 //这个接口中,有且只有一个方法，是实现类必须实现的，所以这个是函数式接口。 interface Test1{ void sayHello(); } //这个接口中,实现类必须实现的方法有2个,所以这个不是一个函数式接口。 interface Test2{ void sayHello(); void sayByeBye(); } //这个接口中,实现类必须实现的方法有0个,所以这个不是一个函数式接口。
Java8 lambda表达式实战技巧揭秘
Java8中引入的lambda表达式为Java语言带来了函数式编程的特性，极大地提高了代码的简洁性和开发效率。Lambda表达式允许我们将代码块作为参数传递给方法，或者作为值赋给变量。这一特性非常适合于实现事件驱动、并行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值