深度探秘 Java 8 函数式编程(下)

java 8 函数式编程 (源码) java8 函数式编程 Richard Warburton著 王群峰译,全书源码(包括课后练习源码) 立即下载

点击上方“芋道源码”,选择“置顶公众号”

技术文章第一时间送达!

源码精品专栏

 

来源:http://t.cn/ELmra8O

  • 函数式编程的益处

  • Java8泛型

  • 完整代码示例

  • 小结


函数式编程的益处

更精练的代码

函数编程的一大益处,是用更精练的代码表达常用数据处理模式。函数接口能够轻易地实现模板方法模式,只要将不确定的业务逻辑抽象成函数接口,然后传入不同的lambda表达式即可。博文“精练代码:一次Java函数式编程的重构之旅” 展示了如何使用函数式编程来重构常见代码,萃取更多可复用的代码模式。

这里给出一个列表分组的例子。实际应用常常需要将一个列表 List[T] 转换为一个 Map[K, List[T]] , 其中 K 是通过某个函数来实现的。 看下面一段代码:

public static Map<String, List<OneRecord>> buildRecordMap(List<OneRecord> records, List<String> colKeys) {
    Map<String, List<OneRecord>> recordMap = new HashMap<>();
    records.forEach(
        record -> {
          String recordKey = buildRecordKey(record.getFieldValues(), colKeys);
          if (recordMap.get(recordKey) == null) {
            recordMap.put(recordKey, new ArrayList<OneRecord>());
          }
          recordMap.get(recordKey).add(record);
    });
    return recordMap;
  }

可以使用 Collectors.groupingby 来简洁地实现:

public static Map<String, List<OneRecord>> buildRecordMapBrief(List<OneRecord> records, List<String> colKeys) {
    return records.stream().collect(Collectors.groupingBy(
        record -> buildRecordKey(record.getFieldValues(), colKeys)
    ));
  }

很多常用数据处理算法,都可以使用函数式编程的流式计算简洁表达。

更通用的代码

使用函数接口,结合泛型,很容易用精练的代码,写出非常通用的工具方法。 实际应用中,常常会有这样的需求: 有两个对象列表srcList和destList,两个对象类型的某个字段K具有相同的值;需要根据这个相同的值合并对应的两个对象的信息。

这里给出了一个列表合并函数,可以将一个对象列表合并到指定的对象列表中。实现是: 先将待合并的列表srcList根据key值函数keyFunc构建起srcMap,然后遍历dest列表的对象R,将待合并的信息srcMap[key]及T通过合并函数mergeFunc生成的新对象R添加到最终结果列表。

  public static <K,R> List<R> mergeList(List<R> srcList, List<R> destList ,
                                        Function<R,K> keyFunc,
                                        BinaryOperator<R> mergeFunc) {
    return mergeList(srcList, destList, keyFunc, keyFunc, mergeFunc);
  }

  public static <T,S,K,R> List<R> mergeList(List<S> srcList, List<T> destList ,
                                            Function<S,K> skeyFunc, Function<T,K> dkeyFunc,
                                            BiFunction<S,T,R> mergeFunc) {

    Map<K,S> srcMap = srcList.stream().collect(Collectors.toMap(skeyFunc, s -> s, (k1,k2) -> k1));
    return destList.stream().map(
        dest -> {
          K key = dkeyFunc.apply(dest);
          S src = srcMap.get(key);
          return mergeFunc.apply(src, dest);
        }
    ).collect(Collectors.toList());

  }

更可测的代码

使用函数接口可以方便地隔离外部依赖,使得类和对象的方法更纯粹、更具可测性。博文“使用Java函数接口及lambda表达式隔离和模拟外部依赖更容易滴单测”,“改善代码可测性的若干技巧”集中讨论了如何使用函数接口提升代码的可单测性。

组合的力量

函数编程的强大威力,在于将函数接口组合起来,构建更强大更具有通用性的实用工具方法。超越类型,超越操作与数据的边界。

前面提到,函数接口就是数据转换器。比如Function 就是“将T对象转换成R对象的行为或数据转换器”。对于实际工程应用的普通级函数编程足够了。不过,要玩转函数接口,就要升级下认识。 比如 Function<bifunction, Function> 该怎么理解呢?这是“一个一元函数g(h(s,q)) ,参数指定的二元函数h(s,q)应用于指定的两个参数S,Q,得到一个一元函数f(t),这个函数接收一个T对象,返回一个R对象”。 如下代码所示:</bifunction

  public static <T,S,Q,R> Function<BiFunction<S,Q,R>, Function<T,R>> op(Function<T,S> funcx, Function<T,Q> funcy) {
    return opFunc -> aT -> opFunc.apply(funcx.apply(aT), funcy.apply(aT));
  }

  System.out.println(op(x-> x.toString().length(), y-> y+",world").apply((x,y) -> x+" " +y).apply("hello"));

实现的是 h(t) = h(funx(t), funy(t)) ,h(x,y) 是一个双参数函数。

“Java函数接口实现函数组合及装饰器模式” 展示了如何使用极少量的代码实现装饰器模式,将简单的函数接口组合成更强大功能的复合函数接口。

来看上面的 public static <T,S,K,R> List<R> mergeList(List<S> srcList, List<T> destList , Function<S,K> skeyFunc, Function<T,K> dkeyFunc,BiFunction<S,T,R> mergeFunc) , 通用性虽好,可是有5个参数,有点丑。怎么改造下呢? 看实现,主要包含两步:1. 将待合并列表转化为 srcMap: map; 2. 使用指定的函数 dKeyFunc, mergeFunc 作用于destList和srcMap,得到最终结果。可以改写代码如下:

public static <T,S,K,R> List<R> mergeList(List<S> srcList, List<T> destList ,
                                          Function<S,K> skeyFunc, Function<T,K> dkeyFunc,
                                          BiFunction<S,T,R> mergeFunc) {
    return join(destList, mapKey(srcList, skeyFunc)).apply(dkeyFunc, (BiFunction) mergeFunc);

  }

  public static <T,K> Map<K,T> mapKey(List<T> list, Function<T,K> keyFunc) {
    return list.stream().collect(Collectors.toMap(keyFunc, t -> t, (k1,k2) -> k1));
  }

  public static <T,S,K,R> BiFunction<Function<T,K>, BiFunction<S,T,R>, List<R>> join(List<T> destList, Map<K,S> srcMap) {
    return (dkeyFunc,mergeFunc) -> destList.stream().map(
        dest -> {
          K key = dkeyFunc.apply(dest);
          S src = srcMap.get(key);
          return mergeFunc.apply(src, dest);
        }).collect(Collectors.toList());
  }

System.out.println(mergeList(Arrays.asList(1,2), Arrays.asList("an", "a"), s-> s, t-> t.toString().length(), (s,t) -> s+t));

mapKey 是一个通用函数,用于将一个 list 按照指定的 keyFunc 转成一个 Map; join 函数接受一个 list 和待合并的 srcMap, 返回一个二元函数,该函数使用指定的 dkeyFunc 和 mergeFunc 来合并指定数据得到最终的结果列表。这可称之为“延迟指定行为”。现在, mapKey 和 join 都是通用性函数。Amazing !

Java8泛型

在Java8函数式框架的解读中,可以明显看到,泛型无处不在。Java8的泛型推导能力也有很大的增强。可以说,如果没有强大的泛型推导支撑,函数接口的威力将会大打折扣。

完整代码示例

package zzz.study.function;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * Created by shuqin on 17/12/3.
 */
public class FunctionUtil {

  public static <T,R> List<R> multiGetResult(List<Function<List<T>, R>> functions, List<T> list) {
    return functions.stream().map(f -> f.apply(list)).collect(Collectors.toList());
  }

  public static <K,R> List<R> mergeList(List<R> srcList, List<R> destList ,
                                        Function<R,K> keyFunc,
                                        BinaryOperator<R> mergeFunc) {
    return mergeList(srcList, destList, keyFunc, keyFunc, mergeFunc);
  }

  public static <T,S,K,R> List<R> mergeList(List<S> srcList, List<T> destList ,
                                          Function<S,K> skeyFunc, Function<T,K> dkeyFunc,
                                          BiFunction<S,T,R> mergeFunc) {
    return join(destList, mapKey(srcList, skeyFunc)).apply(dkeyFunc, (BiFunction) mergeFunc);

  }

  public static <T,K> Map<K,T> mapKey(List<T> list, Function<T,K> keyFunc) {
    return list.stream().collect(Collectors.toMap(keyFunc, t -> t, (k1,k2) -> k1));
  }

  public static <T,S,K,R> BiFunction<Function<T,K>, BiFunction<S,T,R>, List<R>> join(List<T> destList, Map<K,S> srcMap) {
    return (dkeyFunc,mergeFunc) -> destList.stream().map(
        dest -> {
          K key = dkeyFunc.apply(dest);
          S src = srcMap.get(key);
          return mergeFunc.apply(src, dest);
        }).collect(Collectors.toList());
  }

  /** 对给定的值 x,y 应用指定的二元操作函数 */
  public static <T,S,R> Function<BiFunction<T,S,R>, R> op(T x, S y) {
    return opFunc -> opFunc.apply(x, y);
  }

  /** 将两个函数使用组合成一个函数,这个函数接受一个二元操作函数 */
  public static <T,S,Q,R> Function<BiFunction<S,Q,R>, R> op(Function<T,S> funcx, Function<T,Q> funcy, T x) {
    return opFunc -> opFunc.apply(funcx.apply(x), funcy.apply(x));
  }

  public static <T,S,Q,R> Function<BiFunction<S,Q,R>, Function<T,R>> op(Function<T,S> funcx, Function<T,Q> funcy) {
    return opFunc -> aT -> opFunc.apply(funcx.apply(aT), funcy.apply(aT));
  }

  /** 将两个函数组合成一个叠加函数, compose(f,g) = f(g) */
  public static <T> Function<T, T> compose(Function<T,T> funcx, Function<T,T> funcy) {
    return x -> funcx.apply(funcy.apply(x));
  }

  /** 将若干个函数组合成一个叠加函数, compose(f1,f2,...fn) = f1(f2(...(fn))) */
  public static <T> Function<T, T> compose(Function<T,T>... extraFuncs) {
    if (extraFuncs == null || extraFuncs.length == 0) {
      return x->x;
    }
    return x -> Arrays.stream(extraFuncs).reduce(y->y, FunctionUtil::compose).apply(x);
  }

   public static void main(String[] args) {
     System.out.println(multiGetResult(
         Arrays.asList(
             list -> list.stream().collect(Collectors.summarizingInt(x->x)),
             list -> list.stream().filter(x -> x < 50).sorted().collect(Collectors.toList()),
             list -> list.stream().collect(Collectors.groupingBy(x->(x%2==0? "even": "odd"))),
             list -> list.stream().sorted().collect(Collectors.toList()),
             list -> list.stream().sorted().map(Math::sqrt).collect(Collectors.toMap(x->x, y->Math.pow(2,y)))),
         Arrays.asList(64,49,25,16,9,4,1,81,36)));

     List<Integer> list = Arrays.asList(1,2,3,4,5);
     Supplier<Map<Integer,Integer>> mapSupplier = () -> list.stream().collect(Collectors.toMap(x->x, y-> y * y));

     Map<Integer, Integer> mapValueAdd = list.stream().collect(Collectors.toMap(x->x, y->y, (v1,v2) -> v1+v2, mapSupplier));
     System.out.println(mapValueAdd);

     List<Integer> nums = Arrays.asList(Arrays.asList(1,2,3), Arrays.asList(1,4,9), Arrays.asList(1,8,27))
                                .stream().flatMap(x -> x.stream()).collect(Collectors.toList());
     System.out.println(nums);

     List<Integer> fibo = Arrays.asList(1,2,3,4,5,6,7,8,9,10).stream().collect(new FiboCollector());
     System.out.println(fibo);

     System.out.println(op(new Integer(3), Integer.valueOf(3)).apply((x,y) -> x.equals(y.toString())));

     System.out.println(op(x-> x.length(), y-> y+",world", "hello").apply((x,y) -> x+" " +y));

     System.out.println(op(x-> x, y-> y+",world").apply((x,y) -> x+" " +y).apply("hello"));

     System.out.println(op(x-> x.toString().length(), y-> y+",world").apply((x,y) -> x+" " +y).apply("hello"));

     System.out.println(mergeList(Arrays.asList(1,2), Arrays.asList("an", "a"),
                                  s-> s, t-> t.toString().length(), (s,t) -> s+t));

   }

}

小结

本文深入学习了Java8函数式编程框架:Function&Stream&Collector,并展示了函数式编程在实际应用中所带来的诸多益处。函数式编程是一把大锋若钝的奇剑。基于函数接口编程,将函数作为数据自由传递,结合泛型推导能力,可编写出精练、通用、易测的代码,使代码表达能力获得飞一般的提升。



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

已在知识星球更新源码解析如下:

  • 《精尽 Dubbo 源码解析系列》69 篇。

  • 《精尽 Netty 源码解析系列》61 篇。

  • 《精尽 Spring 源码解析系列》35 篇。

  • 《精尽 MyBatis 源码解析系列》34 篇。

  • 《数据库实体设计》17 篇。

  • 《精尽 Spring MVC 源码解析系列》15 篇。

目前在知识星球更新了《Dubbo 源码解析》目录如下:

01. 调试环境搭建
02. 项目结构一览
03. 配置 Configuration
04. 核心流程一览

05. 拓展机制 SPI

06. 线程池

07. 服务暴露 Export

08. 服务引用 Refer

09. 注册中心 Registry

10. 动态编译 Compile

11. 动态代理 Proxy

12. 服务调用 Invoke

13. 调用特性 

14. 过滤器 Filter

15. NIO 服务器

16. P2P 服务器

17. HTTP 服务器

18. 序列化 Serialization

19. 集群容错 Cluster

20. 优雅停机

21. 日志适配

22. 状态检查

23. 监控中心 Monitor

24. 管理中心 Admin

25. 运维命令 QOS

26. 链路追踪 Tracing

... 一共 69+ 篇

目前在知识星球更新了《Netty 源码解析》目录如下:

01. 调试环境搭建
02. NIO 基础
03. Netty 简介
04. 启动 Bootstrap

05. 事件轮询 EventLoop

06. 通道管道 ChannelPipeline

07. 通道 Channel

08. 字节缓冲区 ByteBuf

09. 通道处理器 ChannelHandler

10. 编解码 Codec

11. 工具类 Util

... 一共 61+ 篇

目前在知识星球更新了《数据库实体设计》目录如下:

01. 商品模块
02. 交易模块
03. 营销模块
04. 公用模块

... 一共 17+ 篇

目前在知识星球更新了《Spring 源码解析》目录如下:

01. 调试环境搭建
02. IoC Resource 定位
03. IoC BeanDefinition 载入

04. IoC BeanDefinition 注册

05. IoC Bean 获取

06. IoC Bean 生命周期

... 一共 35+ 篇

目前在知识星球更新了《MyBatis 源码解析》目录如下:

01. 调试环境搭建
02. 项目结构一览
03. MyBatis 面试题合集

04. MyBatis 学习资料合集

05. MyBatis 初始化

06. SQL 初始化

07. SQL 执行

08. 插件体系

09. Spring 集成

... 一共 34+ 篇

源码不易↓↓↓↓↓

点赞支持老艿艿↓↓

java外卖小程序源码+springboot+vue+mybatis 外卖小程序最新开发,springboot+vue+mybatis技术 餐饮小程序-点餐,商家轻松管理,更高效,更便捷的经营方式,餐饮微信领航者,助您轻松实现线上线下融合! 主要功能: 多店商家版、 预定菜品、跑腿、商家、用户注册 立即下载

相关推荐

java8函数式编程源码

java8函数式编程源码。前面讲解Lambda表达式的基本规则,后面介绍如何使用Lambda表达式优化现有代码,提交并发等等。

java8 函数式接口

函数式接口 函数式接口(Functional Interface)就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。 函数式接口可以被隐式转换为lambda表达式。 这些接口在java.util.function包中。 @FunctionalInterface Java 8 为函数式接口引入了一个新注解“@FunctionalInterface”,主要用于编译级错误检查,加上该注解,当...

悠闲咖啡007的博客 377

Rust 与 C/C++:Rust 比 C/C++ 更好还是只是“技能问题”?

对于许多嵌入式系统开发人员而言,的崛起似乎掀起了一股不小的浪潮,特别是在相较于传统的语言,Rust的“内存安全”优势让人眼前一亮。然而,是否可以将Rust作为C/C++的替代品?或者说,Rust是否真的比C/C++更好,抑或它只是一个“技能问题”呢?在嵌入式开发的领域,我观察到,尽管Rust在一些高性能、内存安全敏感的场景中受到了广泛推崇,但它在实际应用中的普及度,特别是在嵌入式领域,依然有限。今天,我会从多个角度探讨这个问题,并且分享一些对于Rust、C/C++以及嵌入式系统开发的个人见解。

qq_63315166的博客 1301

java8中的函数式数据处理

1、在流中只能遍历一次,否则会提示流已经操作或者关闭的错误 List<String> title = Arrays.asList("Java8", "In", "Action"); Stream<String> stream = title.stream(); stream.forEach(System.out::println); stream.forEach(System.out::println); 2、操作类型分为中间操作和...

多看多听多总结 691

告别乱码!ESP32+LVGL显示中文的保姆级教程(基于ESP-IDF,附7000字库生成)

本文详细介绍了如何在ESP32上使用LVGL显示中文的完整解决方案,包括中文字库生成、ESP-IDF工程集成和优化技巧。通过7000字库生成和实战案例,帮助开发者彻底解决中文乱码问题,适用于智能家居、智能手表等嵌入式设备开发。

weixin_28740299的博客 397

如何实现C++动态调用动态链接库(DLL或SO)

使用函数指针来定义函数的类型,以便在动态库中找到的函数能够正确地调用。函数指针的类型必须与函数的签名(参数类型和返回类型)匹配。// 函数指针#ifdef _MSC_VER // Windows环境下的导出声明__declspec。

weixin_48438353的博客 7985

Java8 Function接口详解

Java8为函数式接口引入了一个新注解,主要用于编译级错误检查,加上该注解,当接口不符合函数式接口定义的时候,编译器会报错。对于接口是不是函数式接口没有影响,该注解只是提醒编译器去检查该接口是否仅包含一个抽象方法。。函数式接口就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。对于Stream流大家常用的方法中集合个所有的Function类型,下面逐个介绍条件筛选对单个item对象转换操作对item对象操作,并返回一个新的Stream流循环遍历条件筛选,整个集合item有一个为条件筛选,全部。

程序猿进阶 3228

从时序博弈到数据稳定:CS1237驱动中的信号滤波与卡尔曼实践

本文探讨了CS1237高精度ADC驱动在复杂工业环境中的信号处理挑战,重点介绍了一阶滤波与自适应卡尔曼滤波算法的实践应用。通过参数优化和动态调整策略,有效提升了数据稳定性和抗干扰能力,为嵌入式系统在噪声环境下的精密测量提供了可靠解决方案。

rnn9storyteller的博客 866

jdk8 | Function<T,R>实践应用

自动JDK8诞生,基于stream api的程序编码成为程序员秀代码的平台。事实上,除了stream相关api外,提供的lambda表达式,更新精简了不少代码。然而,对于大多数开发者而言,灵活运用基于函数式编程依然窃取,倘若灵活使用jdk8的相关函数式编程,可以有效精简我们的冗余代码,使得我们的代码可以更灵活的复用。这边,今天来谈谈JDK8中的Function具体该如何更灵活的运用,相信通过这篇文章,你有所收获。.........

秋夜无霜 649

MCGS触摸屏Modbus TCP通讯实战:从寄存器写入到字符串处理的完整代码解析

本文详细解析了MCGS触摸屏通过Modbus TCP协议实现寄存器写入和字符串处理的完整代码,涵盖单寄存器写入、多寄存器写入及字符串传输等核心技术。文章还提供了MCGS组态环境中的实战配置步骤和常见问题排查方法,帮助开发者快速掌握工业自动化通讯的关键技术。

study的专栏 760

预测股票价格趋势:使用MATLAB进行股票价格预测

通过收集股票数据、数据预处理、构建预测模型以及可视化结果,我们可以利用MATLAB强大的计算和分析功能来预测股票价格的走势。然而,需要注意的是,股票市场具有高度复杂性和不确定性,预测结果仅供参考,并不构成投资建议。然而,借助计算机编程和数据分析工具,我们可以利用历史股价数据来建立模型,并预测未来的股票价格走势。首先,我们需要获取股票的历史价格数据。完成模型的拟合后,我们可以使用该模型来进行未来股票价格的预测。最后,我们可以使用MATLAB的绘图功能将预测的股票价格与实际股票价格进行对比,并进行可视化展示。

2301_79326588的博客 1018

Lambda表达式与内置函数式接口、方法引用

Lambda表达式的语法式非常简洁的,但是Lambda表达式不是随随便便使用的,使用时有一个条件要特别注意:1、方法的参数或局部变量类型必须为接口才能使用Lambda。2、接口有且仅有一个抽象方法(@Functionallnterface:唯一抽象方法的类注解)。Lambda表达式项目中常用于Stream流中。

weixin_58780587的博客 362

【WRF-Chem第二期】WRF-Chem有关 namelist 详解

【WRF-Chem第二期】WRF-Chem有关 namelist 详解

WW、forever的博客 2157

accept函数_深度探秘 Java 8 函数式编程(上)

来源:http://t.cn/ELmra8O引子将行为作为数据传递Java8函数框架解读函数接口聚合器流引子将行为作为数据传递怎样在一行代码里同时计算一个列表的和、最大值、最小值、平均值、元素个数、奇偶分组、指数、排序呢?答案是思维反转!将行为作为数据传递。 文艺青年的代码如下所示:publicclassFunctionUtil{publicstaticListmul...

weixin_39675679的博客 598

基于FPGA的万兆以太网学习(1)

万兆(10G) 以太网测速视频:SFP+屏蔽笼可以插入千兆或万兆光模块。SFP+信号定义与 SFP 一致。

baidu_34971492的博客 2250

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

深度探秘 Java 8 函数式编程(上)

引子将行为作为数据传递怎样在一行代码里同时计算一个列表的和、最大值、最小值、平均值、元素个数、奇偶分组、指数、排序呢?答案是思维反转!将行为作为数据传递。 文艺青年的代码...

java面试笔试 255

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Java8 函数式编程探秘

http://www.importnew.com/27901.html

Jayrun_z的博客 293

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

java8函数式编程详解

光看不练只能有个印象,自己手动写出的代码,才能加深学习深度。拿出你的小手敲出自己的示例代码。

金牌程序员东岂 2284

深度探讨Java的Lambda表达式与函数式编程范式

通过深度探讨Lambda表达式及其相关的函数式编程特性,我们不仅仅学会了语法和使用方法,更深入理解了函数式编程的思想。Lambda表达式使得Java更具表达力,代码更为简洁,为开发者提供了更多的选择和灵活性。在实际项目中,合理运用Lambda表达式和函数式编程思想,能够使代码更具可读性、可维护性,提高开发效率。愿读者通过本篇博客,对Java的Lambda表达式有更为深刻的理解。屏幕前的你,祝你今天能够拥有好超级运气!

喔的嘛呀的博客 1330

Java函数式编程深度解析:从Lambda到流式操作

Java 8引入的函数式编程(Functional Programming, FP)特性彻底改变了Java的开发范式。通过Lambda表达式、方法引用和函数式接口,Java代码变得更加简洁、灵活且易于维护。本文将深入探讨Java函数式编程的核心概念、常用函数式接口及其应用场景,并结合实际代码示例展示如何高效使用这些特性。Java函数式编程通过Lambda、方法引用和函数式接口,使代码更简洁、可读性更高。函数式编程是一种编程范式,它将计算视为数学函数的求值,并避免可变状态和副作用。适用于数据转换、映射操作。

hi星尘的博客 1501
上一篇: 深度探秘 Java 8 函数式编程(上)
下一篇: 图解 Elasticsearch 原理
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值