07-001 【java8】Lambda表达式、四大内置核心函数式接口（Consumer/Supplier/Function/Predicate）、方法引用与构造器引用

最新推荐文章于 2023-12-05 11:51:16 发布
最新推荐文章于 2023-12-05 11:51:16 发布
阅读量504 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java高级 文章标签： lambda java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40778497/article/details/104138831
本文深入探讨Java8中Lambda表达式的使用场景、基本语法及优化方式，介绍四大内置核心函数式接口，并讲解方法引用、构造器引用和数组引用的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.Lambda表达式

1.1 为什么使用lambda表达式

package com.magic.java8;

import lombok.*;
import org.junit.Test;

import java.util.*;
//需求1：获取年纪大于35的人
//需求2：获取工资大于6000的人
//在这个类里面根据需求不断写方法，如果继续追加需求呢？怎么优化？
//优化方式1：策略设计模式，一个接口多个实现类，只需要在LambdaDemo类写一个方法，调不同实现类即可
//优化方式2：匿名内部类，在1的基础上使用匿名内部类
//优化方式3：lambda表达式，在2的基础上使用lambda表达式简化

@Data
@Getter
class Employee{
    private int age;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(int age) {
        this.age = age;
    }

    public Employee(int age, String name, double salary) {
        this.age = age;
        this.name = name;
        this.salary = salary;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}
public class LambdaDemo {

    //原来的匿名内部类
    @Test
    public void test01(){
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        };
        TreeSet<Integer> treeSet = new TreeSet<>(com);
    }

    //lambda表达式
    @Test
    public void test02(){
        Comparator<Integer> com = (x,y) ->Integer.compare(x,y);
        TreeSet<Integer> treeSet = new TreeSet<>(com);
    }

    List<Employee> list = Arrays.asList(new Employee(18,"ss",9999.99),
            new Employee(18,"ds",8999.99),
            new Employee(50,"hh",9999.99),
            new Employee(48,"pp",6999.99),
            new Employee(38,"ww",4999.99)
            );

    public List<Employee> filterEmployeeList(List<Employee> list,MyPredicate<Employee> mp){
        List<Employee> employeeList = new ArrayList<>();
        for (Employee e : list){
            if(mp.test(e)){
                employeeList.add(e);
            }
        }
        return employeeList;
    }

    @Test
    public void test06(){
        List<Employee> employeeList = filterEmployeeList(list,employee -> employee.getSalary()>5000);
        System.out.println(employeeList);
    }

	//简化的流式代码
    @Test
    public void test07(){
        list.stream()
                .filter(employee -> employee.getSalary()>5000)
                .limit(2)
                .forEach(System.out::println);

        list.stream().map(Employee::getSalary).forEach(System.out::println);
    }
}

package com.magic.java8;

public interface MyPredicate<T> {
    public boolean test(T t);
}

1.2 lambda表达式的基本语法

lambda表达式基础语法：java8中引入了一个新的操作符“->”该操作符称为箭头操作符或者lambda操作符
操作符分为两部分：

  • 左侧：参数列表
  • 右侧：lambda表达式中所需执行的功能，即lambda体
  1. 语法格式1： 无参无返回值
 ()-> System.out.println("hello lambda")
  1. 语法格式2： 一个参数，无返回值
 (x)-> System.out.println(x)
  1. 语法格式3： 有且只有一个参数，()可以省略
 x-> System.out.println(x)
  1. 语法格式4：有两个以上参数，有返回值，并且lambda体中有多条语句
 Comparator<Integer> comparator = (x,y)->{
              System.out.println("test");
              return Integer.compare(x,y);
          };
  1. 语法格式5：若只有一条语句，{}和return都可以省略不写
 Comparator<Integer> comparator = (x,y)->Integer.compare(x,y);
  1. 语法格式6：参数列表的数据类型可以省略不写，因为jvm编译器可以通过上下文推断出数据类型，即“类型推断”
package com.magic.java8;

import org.junit.Test;

import java.util.Comparator;

/**
 * @Description
 * @Author Chelsea
 * @Date 2020/2/1 18:52
 */

public class LambdaSyntax {

    public void test01(){
        int num = 0;//jdk1.7之前必须是final，现在没有但是实际上也是不可修改的
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world"+num);
            }
        };
        Runnable runnable1 = ()-> System.out.println("hello lambda");
    }

    @Test
    public void test04(){
        Comparator<Integer> comparator = (x,y)->{
            System.out.println("test");
            return Integer.compare(x,y);
        };
    }

    @Test
    public void test05(){
        Comparator<Integer> comparator = (x,y)->Integer.compare(x,y);
    }

    @Test
    public void test07(){
        Integer result = operation(100,num -> num+num);
        System.out.println(result);
    }

    public Integer operation(Integer num,MyFun myFun){
        return myFun.getValue(num);

    }
}

package com.magic.java8;

@FunctionalInterface
public interface MyFun {
    public Integer getValue(Integer num);
}

lambda表达式需要函数式接口的支持
函数式接口：接口中只有一个抽象方法的接口，可以使用注解@FunctionalInterface修饰，可以检查是否是函数式接口

2.四大内置核心函数式接口

函数式接口参数类型返回类型用途
Consumer消费型接口Tvoid对类型为T的对象应用操作，包含方法:void accept(T t)
Supplier供给型接口无T返回类型为T的对象，包含方法:T get()
Function<T,R>函数型接口TR对类型为T的对象应用操作，并返回结果是R类型的对象。包含方法：R apply(T t)
Predicate断定型接口Tboolean确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t)
package com.magic.java8;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @Description
 * @Author Chelsea
 * @Date 2020/2/1 20:03
 *
 * Consumer<T>:消费型接口
 *     void accept(T t)
 * Supplier<T>：供给型接口
 *      T get()
 * Function<T,R>：函数型接口
 *      R apply(T t)
 * Prediction<T>：断言型接口
 *      boolean test(T t)
 */

public class FourCoreInterfaceDemo {

    //Consumer
    @Test
    public void test01(){
        happy(1000,(m)->System.out.println("happy"+m));
    }
    public void happy(double money, Consumer<Double> consumer){
        consumer.accept(money);
    }

    //Supplier
    @Test
    public void test02(){
        List<Integer> numList = getNumList(10, () -> (int)( Math.random() * 100));
        for(Integer i : numList){
            System.out.println(i);
        }
    }
    public List<Integer> getNumList(Integer num, Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            Integer n = supplier.get();
            list.add(n);
        }
        return list;
    }

    //Function
    @Test
    public void test03(){
        System.out.println(strHandler("adadas", (s -> s.substring(1, 3))));
    }
    public String strHandler(String str, Function<String,String> fn){
        return fn.apply(str);
    }

    //Predicate
    @Test
    public void test04(){
        List<String> list = Arrays.asList("qw","www","ok","eeeerg");
        List<String> strList = filterStr(list,(s)->s.length()<3);
        for (String a : strList){
            System.out.println(a);
        }
    }
    public List<String> filterStr(List<String> list, Predicate<String> predicate){
        List<String> strList = new ArrayList<>();
        for (String str: list){
            if(predicate.test(str)){
                strList.add(str);
            }
        }
        return strList;
    }
}

3.对象引用、构造器引用、数组引用

3.1 方法引用

  1. 方法引用：若lambda体中的内容有方法已经实现了，我们可以使用“方法引用”（可以理解为方法引用是lambda表达式的另一种表达形式）
  2. 主要有三种语法格式
  • 对象::实例方法名
  • 类::静态方法名
  • 类::实例方法名
  1. 注意事项：
    1. lambda体中调用方法的参数列表与返回值类型，与函数式接口中抽象方法的函数列表和返回值类型保持一致
    2. 若lambda参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用ClassName::method

3.2构造器引用

  1. 格式： ClassName::new
  2. 注意事项：需要调用的构造器参数列表要与函数式接口中的抽象方法的参数列表保持一致

3.3数组引用

见下面代码

package com.magic.java8;

import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodRefDemo {
    @Test
    public void test1(){
        Consumer<String> consumer = (x)-> System.out.println(x);
        
        PrintStream ps = System.out;
        Consumer consumer1 = ps::println;
    }

    @Test
    public void test2(){
        Comparator<Integer> comparator = (x,y)->Integer.compare(x,y);
        Comparator<Integer> comparator2 = Integer::compare;
    }

    @Test
    public void test3(){
        BiPredicate<String,String> bp = (x,y)->x.equals(y);
        BiPredicate<String,String> bp1 = String::equals;
    }

    //构造器引用
    @Test
    public void test4(){
        Supplier<Employee> supplier = ()->new Employee();
        Supplier<Employee> sup2 = Employee::new;
        Employee employee = sup2.get();
        System.out.println(employee);
    }

    @Test
    public void test5(){
        Function<Integer,Employee> function = (x)->new Employee(x);
        Function<Integer,Employee> function2 = Employee::new;
    }

    //数组引用
    @Test
    public void test6(){
        Function<Integer,String[]> function = (x)->new String[x];
        String [] strs = function.apply(10);
        System.out.println(strs.length);

        Function<Integer,String[]> fun2 = String[]::new;
        String[] strs2 = fun2.apply(20);
        System.out.println(strs2.length);
    }
}

学习整理于Java8新特性.

JAVA中Lambda表达式、函数式接口（Consumer、Supplier、Predicate）详解
zjw541806的博客
06-27 176
​​Lambda表达式​​是一种轻量级的匿名函数语法，用于替代传统的匿名内部类。它的核心作用是​​为函数式接口提供一个简洁的实现​​，避免编写冗长的代码。接口表示“消费一个数据”，其抽象方法接收一个参数（类型T），无返回值。适用于​​处理数据但不返回结果​​的场景（如打印、修改对象状态）。接口表示“提供一个数据”，其抽象方法T get()无参数，返回一个类型T的数据。适用于​​生成或延迟获取数据​​的场景（如随机数生成、从缓存中取数据）。接口表示“对数据进行断言”，其抽象方法接收一个参数（类型T。
掌握 Java 8 函数式编程：Lambda 表达式、方法引用、内置接口与 Stream API
weixin_40228600的博客
06-06 480
本文将带你深入探索 Java 8 中令人兴奋的函数式编程特性，如 Lambda 表达式、方法引用、内置函数式接口和 Stream API。这些特性不仅大幅提升了 Java 语言的表达能力和灵活性，还让编程变得更加简洁和有趣。通过生动的理论讲解和实用示例，你将掌握如何运用这些功能编写出色的代码。无论你是初学者还是经验丰富的开发者，本文都将帮助你轻松驾驭 Java 8 的函数式编程，让你的编程之路更上一层楼。
Lambda 内置四大核心函数接口 ---Predicate 断言型接口 用于判断
qq690452074的专栏
10-08 706
package com.lm; import org.junit.Test; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.function.Function; import java.util.function.Predicate; /** * * Consumer<T> :消费型接口 * void accept(T t) : ...
JAVA8 Predicate接口
鸭鸭的博客
06-06 1万+
predicate 英 [ˈpredɪkət] 美 ['predɪkət] vt. 断言，断定;宣布，宣讲;使基于 vi. 断言，断定 n. 谓语;述语 adj. 谓语的;述语的 上述可以看到，predicate是谓语的意思，在接口中，可以用作判断使用；我们先看接口的定义 @FunctionalInterface public interface Predicate<T&g...
Java8新特性概览——Stream特性，Lambda表达式，函数式接口Function、Predicate、Consumer，方法引用等概述
学习中
04-08 1833
概述： Java 8 新特性概述：https://www.ibm.com/developerworks/cn/java/j-lo-jdk8newfeature/index.html JAVA8 十大新特性详解：https://www.cnblogs.com/xingzc/p/6002873.html 关于lambda表达式： State of the Lambda：http://cr.openjd...
Java 8之Predicate接口方法应用
sinat_31583645的博客
12-20 1030
逻辑表达式：可以连接多个判断条件，&&：与运算符，有false则false，||:或运算符，有true则true，!：非（取反）运算符：非真则假，非假则真。java.util.function.Predicate接口，作用：对某种数据类型的数据进行判断，结果返回一个boolean值。先执行predicate，再执行predicate2 and连接 两者必须都是true 结果才是true。先执行predicate，再执行predicate2 or 连接其中有一个是true，结果就是true。
函数式接口、Lambda表达式、Supplier、Consumer、Predicate、Function
JavaNewMans的博客
08-10 553
Predicate，这个单词意思就是预测，顾名思义该接口的作用就是对给定的参数进行判断，返回值的boolean值。Java中的函数式编程体现的就是Lambda表达式，所以函数式接口通常使用到Lambda表达式。这样使用Lambda表达式很方便的实现了接口中的test()方法，省下了“实现类”的操作。四、函数式接口——Predicate接口。二、函数式接口——Supplier接口。五、函数式接口——Function接口。：有且仅有一个抽象方法的接口。：该方法的返回值是函数式接口。（1）作为方法的参数。....
Java编程Java8新特性详解：默认方法、Lambda表达式及函数式接口的应用与优化Java 8的新
最新发布
04-30
内容概要：本文详细介绍了Java 8的新特性，主要包括默认方法和多重继承、Lambda表达式及其与函数式接口的配合、方法引用、内置函数式接口等内容。默认方法允许接口提供方法的具体实现，但当多个接口有相同默认方法时...
浅析Java8新特性Lambda表达式和函数式接口
08-29
* 四大核心函数式接口：Runnable、Callable、Predicate、Function * 其他函数式接口：Consumer、Supplier、BiFunction 等 Lambda 表达式的优点： * 简化代码：使用 Lambda 表达式可以简化代码，减少冗长的代码量...
掌握Java 8四大核心函数式接口：Consumer、Supplier、Predicate与Function
Java 8 引入了多个函数式接口，它们属于Java 8新引入的Lambda表达式和Stream API的一部分。函数式接口主要以行为参数化作为核心概念，允许将行为作为参数传递给方法。本篇文章将深入探讨四个常用的函数式接口：...
java8之lambda四种基本的函数式接口
dengdai123654的博客
03-22 1000
四中基本的函数式接口
Java Lambda表达式、Consumer、Function、BinaryOperator、Predicate、Supplier、UnaryOperator接口
高万禄的博客
07-01 451
Lambda表达式、 Main.java package Lambda表达式; public class Main { public String message="你好"; public static void main(String[]argv){ /* 功能性接口:只有一个抽象方法 */ greet(new ConsolePrinter()); //使用匿名类 greet(new Pri
Java8新特性之lambda表达式(带实例)及新接口(Consumer、Supplier、Function、Predicate)
shuai_ge_feng的博客
03-24 2982
lambda表达式什么是Lambda表达式函数式接口1使用案例2**来一个带参数的用法**3来一个带参数和返回值的方法引用如何构建方法引用跳过理论看案例函数式接口内置4大接口Predicate：断言型接口Consumer 接口(消费者) 什么是Lambda表达式 可以把Lambda表达式理解为可传递的匿名函数的一种方式 它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。这个定义够大的，让我们慢慢道来。 学习lambda表达式就要先知道函数式接口是什么？ 函数式接口 函数式接口（
【Java 基础篇】Java Lambda表达式详解
繁依Fanyi的博客
09-22 470
Lambda表达式，也称为闭包，是一种匿名函数，它可以传递到方法作为参数，并且可以在方法中使用。它是Java 8引入的一个新特性，用于简化代码的编写，特别是在使用函数式接口时。匿名性：Lambda表达式没有显式的名称，因此可以被当做一种匿名函数使用。简洁性：Lambda表达式可以大大减少代码的冗余，使代码更加简洁。传递性：Lambda表达式可以作为参数传递给方法，从而实现更灵活的代码组织。除了Java标准库中的函数式接口，您还可以定义自己的函数式接口，以适应特定的需求。// 结果为8。
【Java】函数式接口
少年你真的要止步于此嘛。
08-20 3728
函数式接口、函数式编程、常用函数式接口、
Java之Lambda表达式和函数式接口（常用接口：Supplier、Consumer、Predicate、Function）
zz2230633069的博客
12-16 1542
编程思想 面向对象的思想：做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情。 函数式编程思想：只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程。 ...
死磕Lambda表达式（六）：Consumer、Predicate、Function复合
热门推荐
万猫学社
03-13 1万+
JDK不仅提供的这些函数式接口，其中一些接口还为我们提供了实用的默认方法，这次我们来介绍一下Consumer、Predicate、Function复合。
java中lambda中Consumer＜T＞作为函数参数的使用
weixin_44808225的博客
12-05 855
Consumer接口是Java 8中的一个函数式接口，它包含一个抽象的accept方法，可以接受一个参数并执行某些操作，通常用于对集合或流中的每个元素进行遍历和处理。其中，T是表示该方法接受的参数类型，accept方法接收一个T类型的参数，并执行具体的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值