Java：使用BigDecimal、NumberFormat和DecimalFormat保留小数

最新推荐文章于 2024-08-09 09:57:49 发布
最新推荐文章于 2024-08-09 09:57:49 发布
阅读量496 收藏 5
点赞数 8
分类专栏： # Java知识点 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChinaDragon10/article/details/138926219
版权

一、代码和调试结果

1.1 BigDecimal

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/fa36749de8124266a730817710fdf737.png)
1.2 DecimalFormat

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.3 NumberFormat

在这里插入图片描述

二、原代码

BigDecimalUtil.java 代码

package utils;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalUtil {
    // 默认除法运算精度
    private static final int DEFAULT_DIV_SCALE = 5;

    /**
     * 提供精确的加法运算
     *
     * @param v1
     * @param v2
     * @return
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).doubleValue();
    }

    public static String add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).toString();
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1
     * @param v2
     * @return
     */
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).doubleValue();
    }

    public static String substract(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).toString();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1
     * @param v2
     * @return
     */
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).doubleValue();
    }

    public static String multiply(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).toString();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_UP
     *
     * @param v1
     * @param v2
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2) {
        return divide(v1, v2, DEFAULT_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_UP
     *
     * @param v1
     * @param v2
     * @param scale
     *            表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2, int scale) {
        return divide(v1, v2, scale, RoundingMode.HALF_UP);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
     *
     * @param v1
     * @param v2
     * @param scale
     *            表示需要精确到小数点以后几位
     * @param round_mode
     *            表示用户指定的舍入模式
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2, int scale, RoundingMode round_mode) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, round_mode).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN
     *
     * @param v1
     * @param v2
     * @return 两个参数的商，以字符串格式返回
     */
    public static String divide(String v1, String v2) {
        return divide(v1, v2, DEFAULT_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_UP
     *
     * @param v1
     * @param v2
     * @param scale
     *            表示需要精确到小数点以后几位
     * @return 两个参数的商，以字符串格式返回
     */
    public static String divide(String v1, String v2, int scale) {
        return divide(v1, v2, scale, RoundingMode.HALF_UP);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
     *
     * @param v1
     * @param v2
     * @param scale
     *            表示需要精确到小数点以后几位
     * @param round_mode
     *            表示用户指定的舍入模式
     * @return 两个参数的商，以字符串格式返回
     */
    public static String divide(String v1, String v2, int scale, RoundingMode round_mode) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.divide(b2, scale, round_mode).toString();
    }

    /**
     * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN
     *
     * @param v
     *            需要四舍五入的数字
     * @param scale
     *            小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        return round(v, scale, RoundingMode.HALF_UP);
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v
     *            需要四舍五入的数字
     * @param scale
     *            小数点后保留几位
     * @param round_mode
     *            指定的舍入模式
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale, RoundingMode round_mode) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        return b.setScale(scale, round_mode).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_UP
     *
     * @param v
     *            需要四舍五入的数字
     * @param scale
     *            小数点后保留几位
     * @return 四舍五入后的结果，以字符串格式返回
     */
    public static String round(String v, int scale) {
        return round(v, scale, RoundingMode.HALF_UP);
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v
     *            需要四舍五入的数字
     * @param scale
     *            小数点后保留几位
     * @param round_mode
     *            指定的舍入模式
     * @return 四舍五入后的结果，以字符串格式返回
     */
    public static String round(String v, int scale, RoundingMode round_mode) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, round_mode).toString();
    }
}

TestBigDecimal.java代码

package test;

import utils.BigDecimalUtil;
import utils.PrintlnUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;

public class TestBigDecimal {
    public static void main(String[] args) {
        test1();
        test2();
    }

    public static void test1() {
        BigDecimal a = new BigDecimal("10");
        BigDecimal b = new BigDecimal("5");
        BigDecimal c = null;

        /*
            RoundingMode.HALF_UP
            5.5     6
            2.5     3
            1.6     2
            1.1     1
            1.0     1
           -1.0    -1
           -1.1    -1
           -1.6    -2
           -2.5    -3
           -5.5    -6

            ------------------------------

            BigDecimal.ROUND_CEILING
            5.5         6
            2.5         3
            1.6         2
            1.1         2
            1.0         1
           -1.0        -1
           -1.1        -1
           -1.6        -1
           -2.5        -2
           -5.5        -5
         */

        //1.加法-add
//          c = a.add(b);
        //c = 15
//        c = a.add(b).setScale(2,BigDecimal.ROUND_HALF_UP) // 过时了
        c = a.add(b).setScale(2, RoundingMode.HALF_UP);// 2 表示：保留两位小数
        PrintlnUtils.println("c = " + c);
        //c = 15.00

        //2.减法-subtract
        c = a.subtract(b).setScale(2, RoundingMode.HALF_UP);
        PrintlnUtils.println("c = " + c);
        // c = 5.00

        String substract = BigDecimalUtil.substract("10", "5");
        PrintlnUtils.println("BigDecimalUtil.substract = " + substract);
        // BigDecimalUtil.substract = 5

        String substract2 = BigDecimalUtil.substract("10.00", "5");
        PrintlnUtils.println("BigDecimalUtil.substract = " + substract2);
        // BigDecimalUtil.substract = 5.00

        String substract3 = BigDecimalUtil.substract("10.0", "5");
        PrintlnUtils.println("BigDecimalUtil.substract = " + substract3);
        // BigDecimalUtil.substract = 5.0

        String substract4 = BigDecimalUtil.substract("10.0", "5.00");
        PrintlnUtils.println("BigDecimalUtil.substract = " + substract4);
        // BigDecimalUtil.substract = 5.00

        String substract5 = BigDecimalUtil.substract("10", "5.0");
        PrintlnUtils.println("BigDecimalUtil.substract = " + substract5);
        // BigDecimalUtil.substract = 5.0


        //乘法-multiply
        c = a.multiply(b).setScale(2, RoundingMode.HALF_UP);
        PrintlnUtils.println("c = " + c);
        // c = 50.00

        //除法-divide
        c = a.divide(b).setScale(2, RoundingMode.HALF_UP);
        PrintlnUtils.println("c = " + c);
        //c = 2.00

        c = a.divide(new BigDecimal(100), 2, RoundingMode.HALF_UP);
        PrintlnUtils.println("c = " + c);
        //c = 0.10

        //整数舍弃零
        DecimalFormat df = new DecimalFormat("###.##");
        String s1 = df.format(new BigDecimal(88.88));
        String s2 = df.format(new BigDecimal(66.00));
        String s3 = df.format(new BigDecimal(66.15));
        String s4 = df.format(new BigDecimal(-66.15));
        String s5 = df.format(new BigDecimal(666.15));
        String s6 = df.format(new BigDecimal(666.10));
        String s7 = df.format(new BigDecimal(666.1));
        String s8 = df.format(new BigDecimal(666.5));
        String s9 = df.format(new Double(10666.50));
        String s92 = df.format(new Double(10666.52));
        String s93 = df.format(new Double(10666.3));
        String s94 = df.format(new Double(10666.00));
        String s95 = df.format(new Double(10666.5));
        PrintlnUtils.println("s1 = "+s1);//  s1 = 88.88
        PrintlnUtils.println("s2 = "+s2);//  s2 = 66
        PrintlnUtils.println("s3 = "+s3);//  s3 = 66.15
        PrintlnUtils.println("s4 = "+s4);//  s4 = -66.15
        PrintlnUtils.println("s5 = "+s5);//  s5 = 666.15
        PrintlnUtils.println("s6 = "+s6);//  s6 = 666.1
        PrintlnUtils.println("s7 = "+s7);//  s7 = 666.1
        PrintlnUtils.println("s8 = "+s8);//  s8 = 666.5
        PrintlnUtils.println("s9 = "+s9);//  s9 = 10666.5
        PrintlnUtils.println("s92 = "+s92);//  s92 = 10666.52
        PrintlnUtils.println("s93 = "+s93);//  s93 = 10666.3
        PrintlnUtils.println("s94 = "+s94);//  s94 = 10666
        PrintlnUtils.println("s95 = "+s95);//  s95 = 10666.5
    }

    public static void test2() {
        PrintlnUtils.println("test2 ---------------------------------------------------------------------------------------");
        // BigDecimal
        // 保留两位小数
        System.out.println(new BigDecimal(0.2).setScale(2, RoundingMode.HALF_UP).doubleValue());// 0.2
        System.out.println(new BigDecimal(0.235).setScale(2, RoundingMode.HALF_UP).doubleValue());// 0.23
        System.out.println(new BigDecimal(0.2351).setScale(2, RoundingMode.HALF_UP).doubleValue());// 0.24
        System.out.println(new BigDecimal(42).setScale(2, RoundingMode.HALF_UP).doubleValue());// 42.0
        PrintlnUtils.println(" ---------------------------------------------------------------------------------------");
        System.out.println(new BigDecimal(0.2).setScale(2, RoundingMode.HALF_UP));// 0.20
        System.out.println(new BigDecimal(0.235).setScale(2, RoundingMode.HALF_UP));// 0.23
        System.out.println(new BigDecimal(0.2351).setScale(2, RoundingMode.HALF_UP));// 0.24
        System.out.println(new BigDecimal(42).setScale(2, RoundingMode.HALF_UP));// 42.00

        PrintlnUtils.println(" ---------------------------------------------------------------------------------------");

        // NumberFormat
        // 保留两位小数，个位无数字填充 0
        NumberFormat nformat  = NumberFormat.getInstance();
        nformat.setMaximumFractionDigits(2);
        System.out.println(nformat.format(0.2));// 0.2
        System.out.println(nformat.format(0.235));// 0.23
        System.out.println(nformat.format(0.2351));// 0.24
        System.out.println(nformat.format(42));// 42

        PrintlnUtils.println(" ---------------------------------------------------------------------------------------");

        // DecimalFormat，是NumberFormat的具体实现子类
        // 保留两位小数，对应位上无数字填充0
        DecimalFormat df = new DecimalFormat("#0.00");
        df.setRoundingMode(RoundingMode.CEILING);

        System.out.println(df.format(0.2));// 0.20
        System.out.println(df.format(0.235));// 0.23
        System.out.println(df.format(0.2351));// 0.24, 因为0.2351在0.23-0.24之间，距离0.24更近，所以输出0.24
        System.out.println(df.format(42));// 42.00

        PrintlnUtils.println(" ---------------------------------------------------------------------------------------");


        DecimalFormat df4 = new DecimalFormat();

        // #：位置上无数字不显示
        df4.applyPattern("#.##");
        System.out.println(df4.format(345235.0));// 345235
        System.out.println(df4.format(345235.01245));// 345235
        System.out.println(df4.format(345235.0156));// 345235
        System.out.println(df4.format(345235.425));// 345235

        PrintlnUtils.println(" ---------------------------------------------------------------------------------------");

        DecimalFormat df42 = new DecimalFormat("0.00");
        System.out.println(df42.format(345235.0));
        System.out.println(df42.format(345235.01245));
        System.out.println(df42.format(345235.0156));
        System.out.println(df42.format(345235.425));

        //345235.00
        //345235.01
        //345235.02
        //345235.42

        PrintlnUtils.println(" ---------------------------------------------------------------------------------------");

        df42.setRoundingMode(RoundingMode.CEILING);

        System.out.println(df42.format(345235.0));
        System.out.println(df42.format(345235.01245));
        System.out.println(df42.format(345235.0156));
        System.out.println(df42.format(345235.425));

        //345235.00
        //345235.02
        //345235.02
        //345235.43

        PrintlnUtils.println(" ---------------------------------------------------------------------------------------");

        // 0:位置上无数字显示0
        df4.applyPattern("0.00");
        System.out.println(df4.format(345235.0));// 345235.00
        System.out.println(df4.format(345235));// 345235.00

        // 加负数显示
        df4.applyPattern("-0.00");
        System.out.println(df4.format(345235.34567));// -345235.35

        // 逗号分隔
        df4.applyPattern("-0,000.00");
        System.out.println(df4.format(345235.34567));// -345,235.35

        // 百分位
        df4.applyPattern("0.00%");
        System.out.println(df4.format(0.34567));// 34.57%
        // 千分位
        df4.applyPattern("0.00\u2030");
        System.out.println(df4.format(0.34567));// 345.67‰

        // 科学计数法,E之前是底数的格式，E之后的是指数的格式
        df4.applyPattern("0.00E00");
        System.out.println(df4.format(2342.444));// 2.34E03

        // 格式后面加单位符号
        df4.applyPattern("0.00 KG");
        System.out.println(df4.format(2342.444));// 2342.44 KG
        // 格式前面加单位符号
        df4.applyPattern("$ 0.00");
        System.out.println(df4.format(2342.444));// $ 2342.44

        df4.applyPattern("0.00 QA");
        System.out.println(df4.format(2342.444));// 2342.44 QA

        // 使用舍入模式：ROUND_HALF_EVEN，
        // 保留位数是奇数，使用ROUND_HALF_DOWN
        // 保留位数是偶数，使用ROUND_HALF_UP
//        df4.setRoundingMode(RoundingMode.HALF_UP);
        System.out.println(df4.format(2342.435));// 2342.43 QA
        System.out.println(df4.format(2342.445));// 2342.45 QA

        // String.format
        // 保留两位小数，个位数及小数点后两位无数字填充0，四舍五入
        System.out.println(String.format("%.2f", 0.2));// 0.20
        System.out.println(String.format("%.2f", 0.235));// 0.24
        System.out.println(String.format("%.2f", 0.236));// 0.24
        System.out.println(String.format("%.2f", 42.0));// 42.00
    }
}
28、掌握 Java 数学类：Math、Random、BigDecimal 、 NumberFormat和DecimalFormat
2402_87701017的博客
01-22 1039
在 Java 编程中，处理数学运算、随机数生成、高精度计算以及数字格式化是常见的需求。MathRandomBigDecimal和。本文将详细解析这些类的功能和用法。
java保留小数的四种实现方法
09-01
本文将详细介绍四种在Java中保留小数的方法，分别是使用`BigDecimal`、`DecimalFormat`、`String.format()`以及`NumberFormat`类。 1. **使用BigDecimal进行四舍五入** `BigDecimal` 类提供了一个精确的浮点数运算...
java代码-BigDecimal 四舍五入保留2位小数. 金额从单位分转成单位元
07-15
java代码-BigDecimal 四舍五入保留2位小数. 金额从单位分转成单位元
Java中BigDecimal类型的保留小数方法
Asterism33的博客
11-24 957
向 "最近邻位 "舍入的舍入模式，除非两个邻位距离相等，在这种情况下，向偶数邻位舍入。如果舍弃分数左边的数字是奇数，则与 RoundingMode.HALF_UP 相同；如果是偶数，则与 RoundingMode.HALF_DOWN 相同。向 "最近邻近 "舍入，除非两个邻近点距离相等，在这种情况下向下舍入。如果结果为负，则与 RoundingMode.UP 相同。如果结果为负，则与 RoundingMode.UP 相同。四舍五入模式，用于断言所请求的操作具有精确结果，因此无需进行四舍五入。
Java BigDecimal 保留小数工具、BigDecimal常用的方法
weixin_45330393的博客
08-09 365
BigDecimal 保留小数工具、BigDecimal常用的方法
java的几种保留小数位数的方法
yygr的博客
06-10 3636
https://blog.csdn.net/qq_48736958/article/details/115787037?spm=1001.2101.3001.6650.4&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-4-115787037-blog-121975948.pc_relevant_antiscanv2&depth_1-utm_source=distribute.pc_relevant.
格式化数字保留两位小数
lucasey的博客
03-15 3158
（1）使用BigDecimal ，保留小数点后两位public static String format1(double value) { BigDecimal bd = new BigDecimal(value); bd = bd.setScale(2, RoundingMode.HALF_UP); return bd.toString(); } （2）使用
Java中Double除保留后小数位的几种方法(小结)
08-25
在上述方法中，BigDecimal类和DecimalFormat类提供了多种对Double类型数据进行保留小数位的方式，例如四舍五入、五舍六入、直接截掉小数位等。同时，String.format()方法和NumberFormat类也提供了简洁的方式对Double...
如何在Java中实现对浮点数进行保留两位小数的四舍五入操作？请提供使用BigDecimal、DecimalFormat、String.format和NumberFormat的具体代码示例。
最新发布
11-04
这里将详细解释如何使用`BigDecimal`、`DecimalFormat`、`String.format()`和`NumberFormat`这四种方法来完成这一任务，并提供相应的代码示例。 参考资源链接：[Java保留两位小数全攻略：四种方法及示例]...
如何在Java中根据不同场景保留小数位数，并确保格式符合国际化要求？请介绍使用BigDecimal、DecimalFormat、String.format和NumberFormat的具体方法和注意事项。
10-30
在Java中，根据不同的业务场景和国际化需求保留小数位数是一项基础且重要的任务。以下是四种常用的方法及其实现细节： 参考资源链接：[Java实现保留小数位数的四种方法详解]...
Java中BigDecimal除法保留小数位
热门推荐
yuanwxcsdn的博客
03-07 3万+
计算除法，并进行小数位的保留（结果四舍五入、向上取整、向下取整等）的格式： BigDecimal result= 被除数.divide(除数,保留小数位, RoundingMode.结果处理); 说明：1、保留小数位填写Integer类型 2、结果处理（四舍五入、向上取整、向下取整等）通过RoundingMode中枚举来实现，常用的： RoundingMode.UP:直接进位，比如1.22222...
java使用BigDecimal做除法，保留两位小数，且四舍五入
天子笑坛中·
11-17 1万+
【代码】java使用BigDecimal做除法，保留两位小数，且四舍五入。
Java NumberFormat,DecimalFormat保存小数位数
just_coming_here的博客
11-18 3151
使用NumberFormat来保存固定位数的数据 NumberFormat nf = NumberFormat.getInstance(); nf.setMaximumFractionDigits(x);//这个x就是想要设定小数点后面几位的参数 // 这里如果不设置false，当数据超过千的时候就会有分隔符，"3,495.52"，这个时候转换就会因为","关系报错， nf.setGroupi...
保留2位小数，使用java.text.NumberFormat
再难的事，做着做着也就顺了
03-18 1万+
[记录] 保留两位小数，java方式，使用NumberFormat来实现 double sourcePrice = 4940.20;// sourcePrice = 1514940.20 double reductionPrice = 0.1; double price = sourcePrice - reductionPrice; Nu
java Bigdecimal的加减乘除运算及保留小数位
wwwzhouzy的专栏
08-24 5277
一、运算 java.math.BigDecimal。BigDecimal一共有多种够造方法，让我先来看看其中的两种用法： 第一种：BigDecimal(double val) 第二种：BigDecimal(String val) //通常采用这种方式 来看看BigDecimal的四则运算： BigDecimal的四则运算 加法 bigDecimal1.add(bigDecimal2) 减法 bigDecimal1.subtract(bigDecimal2) 乘法 bi.
Java中BigDecimal类型数据保留小数的精度设置
l13913849831的博客
08-14 1万+
BigDecimal数据类型的保留小数的七种方法的区别
BigDecimal&NumberFormat使用
qq_42668504的博客
07-29 647
java中进行浮点数运算时由于计算机底层运算问题可能导致精度丢失，例如: double d1 = 0.3; double d2 = 0.2; System.out.println(d1 - d2);//0.199999999999998 针对以上算术运算预期值应该是：0.2，但是实际结果确是:0.19999999999999998;如果用于表示金额等敏感数值则可能引起极大错误，因此对于精度...
java 保留小数_java保留小数的四种方式
weixin_30764887的博客
02-19 224
import java.math.BigDecimal;import java.text.DecimalFormat;import java.text.NumberFormat;public class FormatNumber {//BigDecimalpublic static void format1(String sf){BigDecimal b = new BigDecimal(sf);...
java中小数金额的比较
cjcxy_202011的博客
08-17 2283
BigDecimal data1 = new BigDecimal(“1”); BigDecimal data2 = new BigDecimal(“1.0”); if (data1.compareTo(data2) < 0) { System.out.println(“第二位数大！”); } if (data1.compareTo(data2) == 0) { System.out.println(“两位数一样大！”); } if (data1.compareTo(data2) > 0) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值