【JAVA】什么是lambda表达式

最新推荐文章于 2024-07-28 19:41:52 发布
最新推荐文章于 2024-07-28 19:41:52 发布
阅读量911 收藏 11
点赞数
分类专栏： 学习笔记 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/for_realz/article/details/128797381
版权

Lambda表达式

一、 Lambda是什么

1. Lambda简述

Lambda表达式是JAVA8中提供的一种新的特性，是一个匿名函数方法。可以把Lambda表达式理解为一段可以传递的代码，可以写出更简洁、更灵活的代码。

编码时，我们一般尽可能轻量级的将代码封装为数据，传统的解决方案是通过接口和实现类（匿名内部类）实现，这中方式存在语法冗余，this关键字，变量捕捉，数据控制等问题，而Lambda表达式的出现便是为了写出更简洁、更灵活的代码（粘贴复制）

简单来说，Lambda表达式是为了让代码更加简洁而设计的一种coding方式，用以简化匿名内部类的代码写法。

2. Lambda表达式的使用

Lambda表达式是对匿名内部类的一种简化，但并非所有的匿名内部类都可以用Lambda表达式来实现。

只有函数式接口的匿名内部类才可以使用Lambda表达式来进行简化。

举例：

  1. 方式1：定义一个类MyRunnable实现Runnable接口，重写run()方法

    //采用自定义类的方式
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("小浩测试lambda方法1！");
    }
}

public class LambdaTest {
    public static void main(String[] args) {
        //新建自定义类对象
        MyRunnable test = new MyRunnable();
        //创建Thread类的对象，把MyRunnable的对象作为构造参数传递
        Thread t = new Thread(test);
        //启动线程
        t.start();
    }
}

  2. 方式2：匿名内部类的方式改进

    public class LambdaTest {
    public static void main(String[] args) {
        //采用匿名内部类的方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("小浩测试lambda方法2！");
            }
        }).start();
    }
}

  3. 方式3：Lambda表达式的方式改进

public class LambdaDemo {
    public static void main(String[] args) {
        //Lambda表达式改进
        new Thread(() -> {
            System.out.println("小浩测试lambda方法3！");
        }).start();
    }
}

通过三种不同的方式实现自定义线程的启动，可以看出Lambda表达式精简了代码，不需要再去定义实体类或者匿名函数重写run方法。使用Lambda表达式来实现需求时，不用关心创建了什么实体类、重写了什么方法。我们只需要关心它最终要做的事情。但是刚接触的话会觉得晦涩难懂，完全不明白这种写法怎么就能实现上述两种方式的功能。

因此，需要先探讨一下lambda表达式的语法、使用条件以及函数式接口等。

3. 函数式编程概述

在数学中，函数就是有输入量、输出量的一套计算方案，也即是“拿数据做操作”。通过函数把输入的数据转换为输出的结果。
而面向对象思想强调“必须通过对象的形式来做事情”，函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

Lambda表达式就是函数式思想的体现。

4. 浅谈函数式接口

简单来说就是只包含一个接口方法的特殊接口，通过@FunctionalInterface注解标注

注意：1、函数式接口中默认接口和静态接口可以正常使用
2、由于Java中所有的类都默认继承自Object类，所以继承自Object类中的接口也可以在函数式接口中使用（如何理解）
3、Java中的函数式编程体现就是Lambda表达式。

如何检测一个接口是不是函数式接口？

@FunctionalInterface放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败。

注意：自定义函数式接口时，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。

函数式接口的两种用法：

  1. 函数式接口做为方法的参数

    package com.test;

public class Test {
    public static void main(String[] args) {
        //方式1：匿名内部类
        startMyThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"测试线程启动");
            }
        });

        //方式2：Lambda表达式
        startThread(()-> System.out.println(Thread.currentThread().getName()+"测试线程启动"));
    }

     private static void startMyThread(Runnable r){
        Thread t = new Thread(r);
        t.start();

    }
}

  2. 函数式接口作为方法的返回值**（重点理解）**

    package com.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<String>();
        array.add("北京大学物理学院");
        array.add("复旦大学计算机学院");
        array.add("厦门大学法学院");
        array.add("四川大学");

        System.out.println("排序前："+array);
        Collections.sort(array);//自然排序
        System.out.println("自然排序后："+array);
        Collections.sort(array,getComparator());
        System.out.println("比较器排序后："+array);

    }

    private static Comparator<String> getComparator(){
	        //匿名内部类方式实现
          Comparator<String> comp=new Comparator<String>() {
              @Override
              public int compare(String s1, String s2) {
                  return s1.length()-s2.length();
              }
  
          };
          return comp;

        //Lambda表达式
          return (String s1,String s2)->{
              return s1.length()-s2.length();
          };
         //Lambda表达式简化版
        return (s1,s2)->s1.length()-s2.length();
    }
}

四个常用的函数式接口

  • Supplier接口
  • Consumer接口
  • Predicate接口
  • Function接口

不展开讲诉了，具体参考Java之函数式接口

5. Lambda表达式的语法

组成Lambda表达式的三要素：形式参数，箭头，代码块

标准格式

Lambda表达式的格式：

  1. 格式： (形式参数) -> {代码块}
  2. **形式参数：**如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
  3. **->：**由英文中画线和大于符号组成，固定写法。代表指向动作
  4. **代码块：**是我们具体要做的事情，也就是以前我们写的方法体内容

省略格式

在Lambda标准格式的基础上，使用省略写法的规则为：

  • 小括号内参数的参数类型可以省略。
  • 小括号有且只有一个参数，则小括号可以直接省略。
  • 如果大括号有且只有一个语句，无论是否有返回值，大括号、return关键字、分号可以省略。

Lambda表达式的使用前提

  1. 有一个接口
  2. 接口中有且仅有一个抽象方法

方法引用

当要传递给Lambda表达式的操作，已经有实现的方法了，就可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用的参数列表一致，方法的返回值也必须一致，即方法的签名一致）。方法引用可以理解为方法引用是Lambda表达式的另外一种表现形式。

方法引用的语法：使用操作符“::”将对象或类和方法名分隔开。

方法引用的使用情况共分为以下三种：

  • 对象::实例方法名
  • 类::静态方法名
  • 类::实例方法名

二、 Lambda表达式实战

1. Lambda表达式语法实战

Lambda表达式在Java语言中引入了一个操作符**“->”**，该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分：

  • 左侧：指定了Lambda表达式需要的所有参数
  • 右侧：制定了Lambda体，即Lambda表达式要执行的功能。

lambda表达式的重要特征:

  • 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

  • 可选的参数圆括号：一个参数无需定义圆括号，但无参数或多个参数需要定义圆括号。

  • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

  • 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

(1) 语法格式一：无参，无返回值，Lambda体只需一条语句。如下：

  @Test
  public void test01(){
    Runnable runnable = ()-> System.out.println("小浩Lambda运行");
    runnable.run();//结果：Runnable 运行
  }

(2) 语法格式二：Lambda需要一个参数，无返回值。如下：

  @Test
  public void test02(){
    Consumer<String> consumer = (x)-> System.out.println(x);
    consumer.accept("小浩Lambda运行");
  }

(3)语法格式三：Lambda只需要一个参数时，参数的小括号可以省略，如下：

  public void test03(){
    Consumer<String> consumer = x-> System.out.println(x);
    consumer.accept("小浩Lambda运行");
  }

(4)语法格式四：Lambda需要两个参数，并且Lambda体中有多条语句。

  @Test
  public void test04(){
    Comparator<Integer> com=(x, y)->{
      System.out.println("函数式接口");
      return Integer.compare(x,y);
    };
    System.out.println(com.compare(2,4));//结果：-1
  }

(5)语法格式五：有两个以上参数，有返回值，若Lambda体中只有一条语句，return和大括号都可以省略不写

  @Test
  public void test05(){
    Comparator<Integer> com=(x, y)-> Integer.compare(x,y);
    System.out.println(com.compare(4,2));//结果：1
  }

(6)Lambda表达式的参数列表的数据类型可以省略不写，因为JVM可以通过上下文推断出数据类型，即“类型推断”

  @Test
  public void test06(){
    Comparator<Integer> com=(Integer x, Integer y)-> Integer.compare(x,y);
    System.out.println(com.compare(4,2));//结果：1
  }

2. 函数式接口详解

**定义：**只包含一个抽象方法的接口，就称为函数式接口。

1）自定义函数式接口

按照函数式接口的定义，自定义一个函数式接口，如下：

@FunctionalInterface
public interface MyFuncInterf<T> {
   public T getValue(String origin);
}

定义一个方法将函数式接口作为方法参数。

  public String toLowerString(MyFuncInterf<String> mf,String origin){
    return mf.getValue(origin);
  }

将Lambda表达式实现的接口作为参数传递。

  public void test(){
      String value=toLowerString((str)->{
        return str.toLowerCase();
      },"ABC");
    System.out.println(value);//结果abc
  }

2）内置函数式接口

  1. Consumer:消费型接口 void accept(T t)

      public void showMusic(Integer music, Consumer<Integer> consumer){
    consumer.accept(money);
  }
 @Test
  public void test(){
    showMusic(10,t-> System.out.println("我今天要听"+t+"首歌"));//结果：我今天要听10首歌
  }

  2. Supplier：供给型接口 T get() （重点理解）

     /**
   * 产生指定的整数集合放到集合中
   * 重点理解！！
   * Iterable接口的forEach方法的定义：方法中使用到了Consumer消费型接口，
   *     default void forEach(Consumer<? super T> action) {
   *         Objects.requireNonNull(action);
   *         for (T t : this) {
   *             action.accept(t);
   *         }
   *     }
   * 版权声明：本文为CSDN博主「Code0cean」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
   * 原文链接：https://blog.csdn.net/huangjhai/article/details/107110182
   */

@Test
    public void test(){
    List list = addNumInList(10, () -> (int) (Math.random() * 10));
    list.forEach(t-> System.out.println(t));
  }
  public List addNumInList(int size, Supplier<Integer> supplier){
    List<Integer> list=new ArrayList();
    for (int i = 0; i < size; i++) {
      list.add(supplier.get());
    }
    return list;
  }

  3. Function<T,R>:函数型接口 R apply(T t)

    public String handleStr(String s,Function<String,String> f){
    return f.apply(s);
  }
@Test
public void test(){
    System.out.println(handleStr("abc",(String s)->s.toUpperCase()));
  }
  //结果：ABC

  4. Predicate:断言型接口 boolean test(T t)

     /**
   *  自定义条件过滤字符串集合
 */
  @Test
  public void test(){
    List<String> strings = Arrays.asList("郑文浩", "四川大学", "计算机学院", "厦门");
    List<String> stringList = filterStr(strings, (s) -> s.length() > 3);
    for (String s : stringList) {
      System.out.println(s);
    }
  }
  public List<String> filterStr(List<String> list, Predicate<String> predicate){
    ArrayList result = new ArrayList();
    for (int i = 0; i < list.size(); i++) {
      if (predicate.test(list.get(i))){
        result.add(list.get(i));
      }
    }
    return result;
  }

  5. 其他接口

3）方法引用

  1. 对象::实例方法名

        //对象::实例方法名
    @Test
    public void test1(){
    PrintStream out = System.out;
    Consumer<String> consumer=out::println; // 这是怎么使用的consumer？
    consumer.accept("im fine");
  }

  2. 类::静态方法名

    /**
 * Integer类中的静态方法compare的定义：
 *     public static int compare(int x, int y) {
 *         return (x < y) ? -1 : ((x == y) ? 0 : 1);
 *     }
 */  
@Test
  public void test2(){
    Comparator<Integer> comparable=(x,y)->Integer.compare(x,y);
    //使用方法引用实现相同效果
    Comparator<Integer> integerComparable=Integer::compare;
    System.out.println(integerComparable.compare(4,2));//结果：1
    System.out.println(comparable.compare(4,2));//结果：1
  }

  3. 类::实例方法名

      @Test
  public void test3(){
    BiPredicate<String,String> bp1=(x,y)->x.equals(y);
    //使用方法引用实现相同效果
    BiPredicate<String,String> bp2=String::equals;
    System.out.println(bp1.test("1","2"));//结果：false
    System.out.println(bp2.test("1","2"));//结果：false
  }

4）构造器

5）数组引用

  @Test
  public void test(){
    Function<Integer,String[]> function=String[]::new;
    String[] apply = function.apply(10);
    System.out.println(apply.length);//结果：10
  }

Lambda表达式可以看作是匿名内部类实例化的对象

在Lambda表达式中规定只能引用标记了final的外层局部变量。我们不能在lambda 内部修改定义在域外的局部变量，否则会编译错误。

//错误示例

public class TestFinalVariable {

    interface VarTestInterface{
        Integer change(String str);
    }
    
    public static void main(String[] args) {
       //局部变量不使用final修饰
        Integer tempInt = 1;
        VarTestInterface var = (str -> Integer.valueOf(str+tempInt));
        //再次修改,不符合隐式final定义
        tempInt =2;
        Integer str =var.change("111") ;
        System.out.println(str);
    }

}

特殊情况下，局部变量也可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

Lambda表达式访问局部变量作限制的原因 （重点理解）

Lambda表达式不能访问非final修饰的局部变量的原因是，局部变量是保存在栈帧中的。而在Java的线程模型中，栈帧中的局部变量是线程私有的，如果允许Lambda表达式访问到栈帧中的变量地址（可改变的局部变量），则会可能导致线程私有的数据被并发访问，造成线程不安全问题。

基于上述，对于引用类型的局部变量，因为Java是值传递，又因为引用类型的指向内容是保存在堆中，是线程共享的，因此Lambda表达式中可以修改引用类型的局部变量的内容，而不能修改该变量的引用。

对于基本数据类型的变量，在 Lambda表达式中只是获取到该变量的副本，且局部变量是线程私有的，因此无法知道其他线程对该变量的修改，如果该变量不做final修饰，会造成数据不同步的问题。

但是实例变量，静态变量不作限制，因为实例变量，静态变量是保存在堆中(Java8之后)，而堆是线程共享的。在Lambda表达式内部是可以知道实例变量，静态变量的变化。

实现原理
①、匿名内部类：编译之后，产生一个单独的.class字节码文件
②、Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

3. Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以 作为解决方案，提升性能。

参考函数式接口看完就懂了

4. Stream应用（具体详见stream专题）

参考详解lambda表达式

参考

  1. Lambda表达式超详细总结 （重点）
  2. 详解Lambda表达式 （重点）
  3. 让你秒懂的Lambda表达式超级详细讲解
  4. Java中的lambda表达式如何理解——精简
  5. 详解lambda表达式2
  6. 函数式接口看完就懂了
Asphyxia_z
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8之lambda表达式基本语法
08-29
Java8之lambda表达式基本语法 Java8中引入的lambda表达式是一种非常强大的语言特性，它可以使我们的代码变得更加简洁、灵活和高效。lambda表达式可以看作是一个匿名函数，可以作为参数传递给方法，也可以直接作为...
详解Java中的Lambda表达式
08-26
Java中的Lambda表达式 Lambda表达式是Java SE 8中一个重要的新特性，它允许开发者通过表达式来代替功能接口。Lambda表达式提供了一个正常的参数列表和一个使用这些参数的主体（body，可以是一个表达式或一个代码块...
Java-lambda表达式与流处理
Lion__king的博客
10-15 264
lambda表达式与流处理
Java 8 lambda表达式
06-27
Java 8 的引入，尤其是Lambda表达式，对Java语言产生了深远的影响，它为Java开发者带来了更简洁、更灵活的编程方式。Lambda表达式是函数式编程的核心元素，它允许我们将函数作为方法参数传递，或者将代码块当作数据...
Java的lambda表达式实现解析
08-30
Java的lambda表达式实现解析 Java的lambda表达式实现解析是Java 8中引入的一项新功能，为开发者提供了更加简洁和灵活的编程方式。lambda表达式可以理解为匿名函数，可以实现在代码中编写小段的函数式代码，从而提高...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
golang 接口
m0_70982551的博客
07-24 931
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 504
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 620
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 583
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 358
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 418
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 844
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 93
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 176
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 865
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 268
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Jvm基础（一）
G81948577的博客
07-19 1080
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
教务管理平台/高校教务管理系统的设计与实现/教务网站/学生成绩管理系统/学生课程管理系统
weixin_47958760的博客
07-27 770
本毕业设计的内容是设计并且实现一个基于JSP技术的教务管理平台。采用MYSQL为数据库开发平台，SSM框架，Tomcat网络信息服务作为应用服务器。教务管理平台的功能已基本实现，主要有学生、教师、课程信息、课程选择、教师课表、学生成绩、图书信息、考试等管理功能。 论文主要从系统的分析与设计 、数据库设计和系统的详细设计等几个方面来进行论述，系统分析与设计部分主要论述了系统的功能分析、系统的设计思路，数据库设计主要论述了数据库的设计，系统的详细设计部分主要论述了几个主要模块的详细设计过程。
android audio不同音频流，(八)music流音量APK按键调整
五味香的专栏
07-24 433
apk通过监测按键事件，再调用AudioManager函数接口，调节STREAM_MUSIC流音量调节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值