Java封装了一个自适应的单位转换工具类

已于 2024-01-26 14:04:33 修改
阅读量949 收藏 8
点赞数 10
文章标签： java spring boot spring maven
于 2024-01-12 17:24:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42555014/article/details/135553264
版权

目录

前言

1、前期准备

2、实现代码

2.1 方法一：通过map去标记需要转换的 类属性字段

2.2 方法二：配合自定义注解

前言

平时在做项目中，经常会做一些数据书籍，尤其像是数据看板之类，需要从数据库中查询想要的数据，但这些数据的单位往往与需求是不匹配的。

比如，数据库中查询的金额是元，但页面上需要展示万元；

亦或是，数据库中查出的距离是米，业务需要的是千米；

又比如，需要将查出的数据除以100，返回前端做百分比展示。等等。。。。。。

那像这种情况，我们是怎么处理的呢？

很多时候我们拿到的是一个数据集合list，然后去遍历集合获取每个参数，再根据参数的属性去做相关的单位转换处理。然后一直重复做着get set，get set，get set。

像这样：

虽然这种写法不会报错，但是看着重复的get set方法，着实是有点孬。所以就封装了一个单位转换的工具类，请看正文。

1、前期准备

  • 接收数据的实体类：
import lombok.Data;

import java.io.Serializable;
import java.math.BigDecimal;

/**
 * 单位转换Vo
 */
@Data
public class UnitConvertVo implements Serializable {

    private static final long serialVersionUID = 4784820539438132009L;

    /*** 日销售额（千元）*/
    private BigDecimal dailySales;

    /*** 年销售额（万元）*/
    private BigDecimal annualSales;

    /*** 营收占比（百分比）*/
    private BigDecimal percentage;

    /*** 营收占比（千分比）*/
    private BigDecimal perMillage;

    /*** 距离*/
    private BigDecimal distance;

    /*** 重量*/
    private BigDecimal weight;

}
  • 定义单位类型枚举类

/**
 * 单位转换枚举
 */
public enum UnitEnum {

    /*** 千元*/
    THOUSAND_YUAN("1", "千元"),
    /*** 万元*/
    TEN_THOUSAND_YUAN("2", "万元"),
    /*** 百分比*/
    PERCENTAGE("3", "百分比"),
    /*** 千分比*/
    PER_MILLAGE("4", "千分比"),
    /*** 米*/
    METER("5", "米"),
    /*** 千米*/
    KILOMETRE("6", "千米"),
    /*** 千克*/
    KILOGRAM("8", "千克"),
    /*** 吨*/
    TON("9", "吨");

    private final String code;

    private final String name;

    UnitEnum(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public String getName() {
        return name;
    }
}

2、实现代码

提供两种方法实现：

2.1 方法一：通过map去标记需要转换的 类属性字段

思路：

1.通过反射取出字段
2.配合传入的转换标记Map，匹配哪些字段需要转换
3.然后从Map中取出相关字段的具体操作有哪些，然后执行转换
4.重新赋值

核心工具类：

import com.test.java.base.UnitEnum;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;
import java.util.Map;

/**
 * 单位转换工具类
 */
@Slf4j
public class UnitConvertUtil {

    /**
     * 方法一：通过反射，获取标识map进行转换
     */
    public static <T> void unitMapConvert(List<T> list, Map<String, UnitEnum> propertyMap) {
        for (T t : list) {
            Field[] declaredFields = t.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                // 匹配map里的字段属性和转换操作
                if (propertyMap.keySet().stream().anyMatch(x -> x.equals(declaredField.getName()))) {
                    try {
                        declaredField.setAccessible(true);
                        Object object = declaredField.get(t);
                        UnitEnum unitEnum = propertyMap.get(declaredField.getName());
                        if (object != null) {// 若匹配上，则执行对应的转换操作（加减乘除）
                            // 元 → 千元
                            if (unitEnum.equals(UnitEnum.THOUSAND_YUAN)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 元 → 万元
                            if (unitEnum.equals(UnitEnum.TEN_THOUSAND_YUAN)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("10000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 百分比
                            if (unitEnum.equals(UnitEnum.PERCENTAGE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("100")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千分比
                            if (unitEnum.equals(UnitEnum.PER_MILLAGE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千米 → 米
                            if (unitEnum.equals(UnitEnum.METER)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 米 → 千米
                            if (unitEnum.equals(UnitEnum.KILOMETRE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 吨 → 千克
                            if (unitEnum.equals(UnitEnum.KILOGRAM)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千克 → 吨
                            if (unitEnum.equals(UnitEnum.TON)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                        }
                    } catch (Exception e) {
                        log.error("单位转换失败，{}", e.getMessage());
                    }
                }
            }
        }
    }


}

写个测试main方法：

    public static void main(String[] args) {

        // 创建测试数据
        UnitConvertVo vo = new UnitConvertVo();
        vo.setDailySales(new BigDecimal("23600.53"));
        vo.setAnnualSales(new BigDecimal("368624.24"));
        vo.setPercentage(new BigDecimal("0.2361"));
        vo.setPerMillage(new BigDecimal("0.536285"));
        vo.setDistance(new BigDecimal("8568.54"));// 米 → 千米
        vo.setWeight(new BigDecimal("35.62638"));// 吨 → 千克

        List<UnitConvertVo> list1 = new ArrayList<>();
        list1.add(vo);

        // 测试方法一：
        Map<String, UnitEnum> map = new HashMap<>();
        map.put("dailySales", UnitEnum.THOUSAND_YUAN);
        map.put("annualSales", UnitEnum.TEN_THOUSAND_YUAN);
        map.put("percentage", UnitEnum.PERCENTAGE);
        map.put("perMillage", UnitEnum.PER_MILLAGE);
        map.put("distance", UnitEnum.KILOMETRE);
        map.put("weight", UnitEnum.KILOGRAM);
        System.out.println("转换前：" + list1);
        unitMapConvert(list1, map);
        System.out.println("通过map标识转换：" + list1);

    }

转换结果：

2.2 方法二：配合自定义注解

其实第一种方法已经够用了，但是为了调用更加的方便，后期能够更好的拓展，所以配合着自定义注解，优化了一下，直接上代码：

  • 定义自定义注解
package com.test.java.annotation;

import com.test.java.base.UnitEnum;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 单位转换 自定义注解
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface UnitConvert {

    UnitEnum name();

}
  • 在实体类上，使用自定义注解

import com.test.java.annotation.UnitConvert;
import com.test.java.base.UnitEnum;
import lombok.Data;

import java.io.Serializable;
import java.math.BigDecimal;

/**
 * 单位转换Vo
 */
@Data
public class UnitConvertVo implements Serializable {

    private static final long serialVersionUID = 4784820539438132009L;

    /*** 日销售额（千元）*/
    @UnitConvert(name = UnitEnum.THOUSAND_YUAN)
    private BigDecimal dailySales;

    /*** 年销售额（万元）*/
    @UnitConvert(name = UnitEnum.TEN_THOUSAND_YUAN)
    private BigDecimal annualSales;

    /*** 营收占比（百分比）*/
    @UnitConvert(name = UnitEnum.PERCENTAGE)
    private BigDecimal percentage;

    /*** 营收占比（千分比）*/
    @UnitConvert(name = UnitEnum.PER_MILLAGE)
    private BigDecimal perMillage;

    /*** 距离*/
    @UnitConvert(name = UnitEnum.METER)
    private BigDecimal distance;

    /*** 重量*/
    @UnitConvert(name = UnitEnum.TON)
    private BigDecimal weight;

}

配合自定义注解，在刚刚的工具类里又封装了一个方法，反射获取属性字段，解析注解，做对应转换操作。

import com.test.java.annotation.UnitConvert;
import com.test.java.base.UnitEnum;
import com.test.java.domain.vo.UnitConvertVo;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

/**
 * 单位转换工具类
 */
@Slf4j
public class UnitConvertUtil {

    /**
     * 方法一：通过反射，获取标识map进行转换
     */
    public static <T> void unitMapConvert(List<T> list, Map<String, UnitEnum> propertyMap) {
        for (T t : list) {
            Field[] declaredFields = t.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                // 匹配map里的字段属性和转换操作
                if (propertyMap.keySet().stream().anyMatch(x -> x.equals(declaredField.getName()))) {
                    try {
                        declaredField.setAccessible(true);
                        Object object = declaredField.get(t);
                        UnitEnum unitEnum = propertyMap.get(declaredField.getName());
                        if (object != null) {// 若匹配上，则执行对应的转换操作（加减乘除）
                            // 元 → 千元
                            if (unitEnum.equals(UnitEnum.THOUSAND_YUAN)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 元 → 万元
                            if (unitEnum.equals(UnitEnum.TEN_THOUSAND_YUAN)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("10000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 百分比
                            if (unitEnum.equals(UnitEnum.PERCENTAGE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("100")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千分比
                            if (unitEnum.equals(UnitEnum.PER_MILLAGE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千米 → 米
                            if (unitEnum.equals(UnitEnum.METER)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 米 → 千米
                            if (unitEnum.equals(UnitEnum.KILOMETRE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 吨 → 千克
                            if (unitEnum.equals(UnitEnum.KILOGRAM)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千克 → 吨
                            if (unitEnum.equals(UnitEnum.TON)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                        }
                    } catch (Exception e) {
                        log.error("单位转换失败，{}", e.getMessage());
                    }
                }
            }
        }
    }

    /**
     * 方法二：通过自定义注解 进行转换
     */
    public static <T> void unitAnnotationConvert(List<T> list) {
        for (T t : list) {
            // 获取属性字段
            Field[] declaredFields = t.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                try {
                    if ("serialVersionUID".equals(declaredField.getName())) {
                        continue;
                    }
                    // 取出字段上的自定义注解
                    UnitConvert myFieldAnn = declaredField.getAnnotation(UnitConvert.class);
                    if (Objects.isNull(myFieldAnn)) {
                        continue;
                    }
                    // 取出注解里面的转换类型枚举
                    UnitEnum unitEnum = myFieldAnn.name();
                    // 赋予超级权限
                    declaredField.setAccessible(true);
                    Object object = declaredField.get(t);
                    if (Objects.nonNull(object)) {// 执行对应的转换操作（加减乘除）
                        // 元 → 千元
                        if (unitEnum.equals(UnitEnum.THOUSAND_YUAN)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 元 → 万元
                        if (unitEnum.equals(UnitEnum.TEN_THOUSAND_YUAN)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("10000"), 2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 百分比
                        if (unitEnum.equals(UnitEnum.PERCENTAGE)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("100")).setScale(2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 千分比
                        if (unitEnum.equals(UnitEnum.PER_MILLAGE)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 千米 → 米
                        if (unitEnum.equals(UnitEnum.METER)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 米 → 千米
                        if (unitEnum.equals(UnitEnum.KILOMETRE)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 吨 → 千克
                        if (unitEnum.equals(UnitEnum.KILOGRAM)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 千克 → 吨
                        if (unitEnum.equals(UnitEnum.TON)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                    }
                } catch (Exception e) {
                    log.error("单位转换失败，{}", e.getMessage());
                }
            }
        }
    }

    public static void main(String[] args) {

        // 创建测试数据
        UnitConvertVo vo = new UnitConvertVo();
        vo.setDailySales(new BigDecimal("23600.53"));
        vo.setAnnualSales(new BigDecimal("368624.24"));
        vo.setPercentage(new BigDecimal("0.2361"));
        vo.setPerMillage(new BigDecimal("0.536285"));
        vo.setDistance(new BigDecimal("8568.54"));// 米 → 千米
        vo.setWeight(new BigDecimal("35.62638"));// 吨 → 千克

        UnitConvertVo vo1 = new UnitConvertVo();
        vo1.setDailySales(new BigDecimal("23600.53"));
        vo1.setAnnualSales(new BigDecimal("368624.24"));
        vo1.setPercentage(new BigDecimal("0.2361"));
        vo1.setPerMillage(new BigDecimal("0.536285"));
        vo1.setDistance(new BigDecimal("8.56854"));// 千米 → 米
        vo1.setWeight(new BigDecimal("35626.38"));// 千克 → 吨

        List<UnitConvertVo> list1 = new ArrayList<>();
        List<UnitConvertVo> list2 = new ArrayList<>();
        list1.add(vo);
        list2.add(vo1);

        // 测试方法一：
        Map<String, UnitEnum> map = new HashMap<>();
        map.put("dailySales", UnitEnum.THOUSAND_YUAN);
        map.put("annualSales", UnitEnum.TEN_THOUSAND_YUAN);
        map.put("percentage", UnitEnum.PERCENTAGE);
        map.put("perMillage", UnitEnum.PER_MILLAGE);
        map.put("distance", UnitEnum.KILOMETRE);
        map.put("weight", UnitEnum.KILOGRAM);
        System.out.println("转换前：" + list1);
        unitMapConvert(list1, map);
        System.out.println("通过map标识转换：" + list1);

        // 测试方法二：
        System.out.println("转换前：" + list2);
        unitAnnotationConvert(list2);
        System.out.println("通过注解标识转换：" + list2);
    }

}

结果：

两种方法都正确的转换了单位，不过我个人推荐第二种方法，方便后期维护。

如果这篇文章对您有所帮助，或者有所启发的话，求一键三连：点赞、评论、收藏➕关注，您的支持是我坚持写作最大的动力。  

Javaの甘乃迪
关注
  • 10
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
动态生成表格工具类
10-12
之前的做了一个需要动态生成表格的项目，表头和左侧列表都是多行多列 项目使用的前端框架无法实现生成效果，自己纯手拼一个，感觉特别麻烦，所有自己写了一个相对工具类实现这个功能
SpringJdbcTemplate封装工具类
06-13
通过上述分析，我们可以看到SpringJdbcTemplate是一个强大且灵活的工具，它通过封装JDBC操作，使得数据库访问变得更加简单和安全。在实际开发中，合理利用其特性，可以有效提升开发效率和代码质量。
JAVA中各种单位之间的转换
热门推荐
LiuWaiter的博客
01-06 1万+
本次讲述的是JAVA中各种单位之间的换算，其中包括货币单位的换算，时间单位的换算，以及小数点的保留和小数点与百分号之间的换算，都是从项目中抽取出来的，可能不太全面，把现有的先记录在这里，后面再继续补充。 （一）首先，这里是货币之间单位的换算：/** * 货币转换 1000000 return 1百万 10000 return 1万 1000 return 1千 * * @param
java 时间工具类封装
最新发布
weixin_41572392的博客
05-22 431
【代码】java 时间工具类封装。
JAVA将字节大小转换成(B,KB,MB,GB,TB)单位
涛哥是个大帅比
06-13 3604
项目中需要判断一个文件是否超过指定大小，如果超过了，需要将文件大小转换为最大满足单位。
Java、Android工具整理 - 单位换算
Android、前端、小程序、后端
08-05 3475
Java、Android中常用的单位换算工具
Java 计量单位换算 工具类
叁金Coder
01-14 3275
使用枚举进行简单计算，现在只有简单常用的单位,如有需要自行添加,以标准单位为基准 源码Gitee 参考代码 import lombok.AllArgsConstructor; import lombok.Getter; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import.
java工具类 单位转化
weixin_38503935的博客
11-15 937
一、金额转换 public static String changeF2Y(String amount) throws Exception { if (!amount.matches("\\-?[0-9]+")) { throw new Exception("分转元"); } return BigDecimal.valueO...
单位转换工具类
路在前方
01-09 575
Java单位转换的工具类： 包含 1.元转分（不保留小数） 2.元转分（保留小数点后两位） 3.分转元（不保留小数） 4.分转元（保留小数点后两位） 5.保留小数点后一位 6.保留小数点后两位 7.保留小数点后三位
html转pdf工具类
02-06
Medway可能是一个JAVA库，封装了如WeasyPrint、Puppeteer或PDFreactor等更底层的转换引擎，这些引擎可以处理HTML到PDF的复杂转换过程。 在实际使用时，开发者需要根据项目需求选择合适的HTML转PDF工具类，考虑兼容...
java仿QQ截图工具
12-28
Java仿QQ截图工具是一款基于Java编程语言开发的实用程序，旨在提供类似QQ截图的功能，让用户能够方便快捷地进行屏幕捕获。...对于学习Java GUI编程和理解图形界面交互逻辑的开发者来说，这是一个极好的实践案例。
java 长度单位转换
07-22
JAVA编写的长度单位转换，可从米转换为英制长度单位，码，英尺和英寸.
JAVA实现的多计量单位转换.rar
07-03
自己用java写的多计量单位转换，比如mg:ml:片；1:2:3 无限极单位转换，提供任意2个单位，获取转换系数。
java编写的简单的单位换算工具
12-05
java编写的简单的单位换算工具 小应用程序，源代码及可执行程序，网页程序
单位转换器
11-21
用Java开发的单位转换器，包含时间,货币,长度,质量,密度,温度,面积,体积,速度,功率,力,压强,功,热导率,气油比,数据存储中常用单位的转换，包含公制，英制，及中国传统单位的换算
常用 单位换算器 Java 源代码
11-18
实现了常用 长度、时间、温度单位的换算, 关于面积、体积、压强、角度等可根据换算公式再代码相应位置中添加。
一个基于canvas开发,封装于Vue组件的通用手写签名板
05-06
6. **Vue组件化**：将上述功能封装为一个Vue组件，需要定义组件的属性（如颜色、线条宽度等）、方法（如开始签名、结束签名、清除签名等）以及生命周期钩子。组件的模板中包含Canvas元素，并通过Vue的绑定机制将用户...
java存储单位换算
qq_39999478的博客
07-21 1528
1KB=1024B； 1MB=1024KB=1024×1024B。 1B（byte，字节bai）= 8 bit（见下文）； 1KB（Kilobyte，千字节）=1024B= 2^10 B； 1MB（Megabyte，兆字节，du百万字节，简称“兆zhi”）=1024KB= 2^20 B； 1GB（Gigabyte，吉字节，十亿字节，又称“千兆”）=1024MB= 2^30 B； 1TB（Terabyte，万亿字节，太字节）=1024GB= 2^40 B； ...
KB、MB、GB java转换工具类
tang_sy的博客
01-17 711
【代码】KB、MB、GB 项目转换工具类。
Java 封装一个工具类
06-13
好的，以下是一个简单的 Java 封装工具类的示例： ```java public class Utils { /** * 将字符串转换为整数 * @param str 字符串 * @return 整数 */ public static int stringToInt(String str) { int num; ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Javaの甘乃迪

感谢看客老爷的打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值