当前位置： 首页 > news >正文

Java Lambda 表达式提升效率

news 2025/7/5 12:15:55

  • lambda 表达式的应用场景

  • Stream 的应用场景

  • Lambda/Stream 的进一步封装

自定义函数式接口（用 jdk 自带的函数式接口也可以）

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

import java.io.Serializable;

/**
 * 可序列化的Functional
 *
 * @author VampireAchao
 */
@FunctionalInterface
public interface Func<T, R> extends Serializable {

    /**
     * 调用
     *
     * @param t 参数
     * @return 返回值
     */
    R apply(T t);
}

/**
 * 可序列化的函数式接口实现类
 *
 * @author VampireAchao
 */
public class FuncImpl implements Func<Object, String> {
    /**
     * 调用
     *
     * @param o 参数
     * @return 返回值
     */
    @Override
    public String apply(Object o) {
        return o.toString();
    }
}

  Func<String, Integer> func = new Func<String, Integer>() {
            /**
             * 调用
             *
             * @param s 参数
             * @return 返回值
             */
            @Override
            public Integer apply(String s) {
                return s.hashCode();
            }
        };

Lambda 这种简写的形式

java.util.stream (Java Platform SE 8 )

 Func<String, String> func1 = (String s) -> {
            return s.toUpperCase();
        };

Func<String, String> func2 = (String s) -> s.toUpperCase();
Func<String, String> func3 = s -> s.toUpperCase();
Func<String, String> func4 = String::toUpperCase;

import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;

/**
 * 语法糖——方法引用
 *
 * @author VampireAchao
 */
public class MethodReferences {

    public static Object staticSupplier() {
        return "whatever";
    }

    public Object instanceSupplier() {
        return "whatever";
    }

    public Object anonymousInstanceFunction() {
        return "whatever";
    }

    public static void main(String[] args) {
        // 引用构造函数
        Supplier<MethodReferences> conSup = () -> new MethodReferences();
        conSup = MethodReferences::new;
        // 数组构造函数引用
        IntFunction<int[]> intFunction = value -> new int[value];
        // intFunc == new int[20];
        int[] intFuncResult = intFunction.apply(20);
        // 引用静态方法
        Supplier<Object> statSup = () -> staticSupplier();
        statSup = MethodReferences::staticSupplier;
        Object statSupResult = statSup.get();
        // 引用特定对象的实例方法
        Supplier<Object> instSup = new MethodReferences()::instanceSupplier;
        instSup = new MethodReferences()::instanceSupplier;
        Object instSupResult = instSup.get();
        // 引用特定类型的任意对象的实例方法
        Function<MethodReferences, Object> anonInstFunc = streamDemo -> streamDemo.anonymousInstanceFunction();
        anonInstFunc = MethodReferences::anonymousInstanceFunction;

    }

}

jdk 自带的函数式接口写法

import java.math.BigDecimal;
import java.util.function.*;

/**
 * 常用的几个函数式接口写法
 *
 * @author VampireAchao
 */
class Usual {

    public static Consumer<Object> consumer() {
        // 有参数无返回值
        return o -> {
        };
    }

    public static Function<Integer, Object> function() {
        // 有参数有返回值
        return o -> o;
    }

    public static Predicate<Object> predicate() {
        // 有参数，返回值为boolean
        return o -> true;
    }

    public static Supplier<Object> supplier() {
        // 无参数有返回值
        return Object::new;
    }

    public static BiConsumer<String, Integer> biConsumer() {
        // 俩参数无返回值
        return (q, o) -> {
        };
    }

    public static BiFunction<Integer, Long, BigDecimal> biFunction() {
        // 俩参数，有返回值
        return (q, o) -> new BigDecimal(q).add(BigDecimal.valueOf(o));
    }

    public static UnaryOperator<Object> unaryOperator() {
        // 一个参数，返回值类型和参数一样
        return q -> q;
    }

    public static BinaryOperator<Object> binaryOperator() {
        // 俩参数和返回值类型保持一致
        return (a, o) -> a;
    }

}

Java 8 API 的抽象称为流 Stream

java.util.stream (Java Platform SE 8 )

    // 声明式编程是告诉计算机需要计算“什么”而不是“如何”去计算
        // 现在，我想要一个List，包含3个数字6
        List<Integer> sixSixSix =
                // 我想要：
                Stream
                        // 数字6
                        .generate(() -> 6)
                        // 3个
                        .limit(3)
                        // 最后收集起来转为List
                        .collect(Collectors.toList());
        sixSixSix.forEach(System.out::print);

//Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

        // 就像sql里的排序、截取
        // 我要把传入的list逆序，然后从第五个(元素下标为4)开始取值，取4条
        abc = abc.stream()
                // 排序(按照自然顺序的逆序)
                .sorted(Comparator.reverseOrder())
                // 从下标为4开始取值
                .skip(4)
                // 取4条
                .limit(4)
                // 最后收集起来转为List
                .collect(Collectors.toList());
        System.out.println("我要把传入的list逆序，然后从第五个(元素下标为4)开始取值，取4条");
        abc.forEach(System.out::print);
        System.out.println();


  /**
     * 老办法实现一个list，存储3个6
     *
     * @return [6, 6, 6]
     */
    private static List<Integer> oldSix() {
        // 老办法
        List<Integer> sixSixSix = new ArrayList<>(3);
        sixSixSix.add(6);
        sixSixSix.add(6);
        sixSixSix.add(6);
        System.out.println("老办法实现一个list，存储3个6");
        for (Integer integer : sixSixSix) {
            System.out.print(integer);
        }
        System.out.println();
        return sixSixSix;
    }

    /**
     * 新方法实现一个list，存储3个6
     *
     * @return [6, 6, 6]
     */
    private static List<Integer> newSix() {
        List<Integer> sixSixSix = Stream.generate(() -> 6).limit(3).collect(Collectors.toList());
        System.out.println("新方法实现一个list，存储3个6");
        sixSixSix.forEach(System.out::print);
        System.out.println();
        return sixSixSix;
    }

   // 管道中传输，节点中处理
        int pipe = abc.stream()
                // 筛选
                .filter(i -> i > 'G')
                // 排序
                .sorted(Comparator.reverseOrder())
                .mapToInt(Object::hashCode)
                // 聚合
                .sum();
        System.out.println("将26个字母组成的集合过滤出大于'G'的，逆序，再获取hashCode值，进行求和");
        System.out.println(pipe);


//元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作 (terminal operation) 得到前面处理的结果。

        // 将26个大写字母Character集合转换为String然后转换为小写字符
        List<String> terminalOperation = abc.stream()
                // 中间操作（intermediate operation）
                .map(String::valueOf).map(String::toLowerCase)
                // 最终操作（terminal operation）
                .collect(Collectors.toList());
        System.out.println("26个大写字母Character集合，转换成String然后转换为小写字符，收集起来");
        terminalOperation.forEach(System.out::print);
        System.out.println();

http://www.dtcms.com/a/109570.html

相关文章：

  • 高效深度学习lecture01
  • Flask与 FastAPI 对比：哪个更适合你的 Web 开发？
  • MySQL（三）
  • 二分类交叉熵损失
  • 在内网环境中为 Gogs 配置 HTTPS 访问
  • 常用的元素操作API
  • chromium魔改——navigator.webdriver 检测
  • 【无人机】无人机PX4飞控系统高级软件架构
  • 创新项目实训开发日志1
  • 21.数据链路层协议
  • 如何在本地部署魔搭上千问Qwen2.5-VL-32B-Instruct-AWQ模型在显卡1上面运行推理，并开启api服务
  • QT 中的元对象系统(五)：QMetaObject::invokeMethod的使用和实现原理
  • JavaScript基础-移动端常用开发框架
  • 智能多媒体处理流水线——基于虎跃办公API的自动化解决方案
  • Redis 除了数据类型外的核心功能 的详细说明，包含事务、流水线、发布/订阅、Lua 脚本的完整代码示例和表格总结
  • 【数据集】多视图文本数据集
  • Python第七章09：自定义python包.py
  • maven引入项目内本地包方法
  • WEB安全--文件上传漏洞--php伪协议的利用
  • MySQL索引(操作篇)
  • 分布式锁之redis6
  • GenerationMixin：_sample方法(GenerationMode.SAMPLE, GenerationMode.GREEDY_SEARCH)
  • 程序员学商务英语之Establing Biz Relations Inquiry
  • 自适应卡尔曼滤波
  • 探索 GitHub Copilot：当 AI 成为你的贴身编码助手
  • Win11本地从零开始部署dify全流程
  • TP6图片操作 Image::open 调用-＞save(）方法时候报错Type is not supported
  • Redis基础知识-3
  • linux - 字符设备驱动简介
  • MySql 数据库题目