服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - Java中的金钱陷阱

Java中的金钱陷阱

2023-06-07 01:16未知服务器之家 Java教程

前言 有多少小伙伴是被标题 骗 吸引进来的呢,我可不是标题党,今天的文章呢确实跟”金钱“有关系。 但是我们说的不是过度追求金钱而掉入陷阱,而是要说一说在Java程序中,各种跟金钱运算有关的陷阱。 日常工作中我们经常

前言

有多少小伙伴是被标题 吸引进来的呢,我可不是标题党,今天的文章呢确实跟”金钱“有关系。

但是我们说的不是过度追求金钱而掉入陷阱,而是要说一说在Java程序中,各种跟金钱运算有关的陷阱。

日常工作中我们经常会涉及到各种金额这样浮点数的运算

一旦涉及到金额的运算就必须慎之又慎,一旦有精度丢失,或者其他运算错误就可能造成无可挽回的损失。

一 、 存在的陷阱

这一小节我们先将陷阱列出来,下一小节分别给出解决方案。

我们先来看看到底有哪些坑等着我们去踩

1.1 浮点运算精度丢失陷阱

public class BigDecimalDemo {
    public static void main(String[] args) {
        float a = 1.0f - 0.9f;
        float b = 0.9f - 0.8f;

        System.out.println("a= "+a);
        System.out.println("b= "+b);

    }
}
//输出结果
a= 0.100000024
b= 0.099999964

1.2 浮点数等值判断陷阱

① 基本类型与包装类型判断浮点数是否相等

public class BigDecimalDemo {
    public static void main(String[] args) {
        float a = 1.0F - 0.9F;
        float b = 0.9F - 0.8F;
        System.out.println("通过==判断a与b是否相等:"+ (a == b));

        Float x = Float.valueOf(a);
        Float y = Float.valueOf(b);

        System.out.println("通过equals方法判断x与y是否相等:"+ x.equals(y));
    }
}
//输出结果
通过==判断a与b是否相等false
通过equals方法判断x y是否相等false

BigDecimal类通过equals 方法判断是否相等

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("2");
        BigDecimal b = new BigDecimal("2.0");
        System.out.println(a.equals(b));

    }
}
//输出结果
false

1.3 BigDecimal 构造方法中的陷阱

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal(0.1f);
        
        System.out.println("a= "+ a);
    }
}
//输出结果
a= 0.100000001490116119384765625

1.4 BigDecimal 除法陷阱

如果两数相除无法除尽,抛出 ArithmeticException 异常

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.2");
        BigDecimal b = new BigDecimal("0.3");

        System.out.println(a.divide(b));
    }
}
//输出结果
Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
	at java.math.BigDecimal.divide(BigDecimal.java:1693)
	at com.xiezhr.BigDecimalDemo.main(BigDecimalDemo.java:17)

二、避免陷阱

2.1 浮点数运算避坑

① 我们先来看看为什么浮点数(也就是floatdouble 关键字定义的数) 运算的时候精度会丢失?

我们直到计算机是以二进制的方式进行数据存储的,在表示一个数字时,宽度时有限的。

十进制的 0.1 转为二进制,得到一个无限循环小数:0.00011… (看不懂的自觉点回去翻一翻大一的《计算机基础》课本)

无限循环的小数存储在计算机时,只能被截断,所以就会导致小数精度发生损失的情况。

这就是为什么浮点数没有办法用二进制精确表示。

我们怎么来填1.1 中的坑呢?

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1.0");
        BigDecimal b = new BigDecimal("0.9");
        BigDecimal c = new BigDecimal("0.9");
        BigDecimal d = new BigDecimal("0.8");

        System.out.println("a-b = "+a.subtract(b));
        System.out.println("c-d = "+c.subtract(d));
    }
}
//输出结果
a-b = 0.1
c-d = 0.1

2.2 浮点数等值判断避坑

日常开发中肯定时免不了比较两个浮点数大小的,这里呢就把1.2中的坑给填上

① 指定一个误差范围,若两个浮点数的差值在误差范围内,则认为两个浮点数时相等的

public class BigDecimalDemo {
    public static void main(String[] args) {
        float a = 1.0F - 0.9F;
        float b = 0.9F - 0.8F;
        //表示10的-6次方
        float diff = 1e-6f;

        if (Math.abs(a - b )< diff) {
            System.out.println("a与b相等");
        }
    }
}
//输出结果
a与b相等

② 使用BigDecimal定义值,再进行运算操作,最后使用compareTo 方法比较

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1.0");
        BigDecimal b = new BigDecimal("0.9");
        BigDecimal c = new BigDecimal("0.8");

        BigDecimal x = a.subtract(b);
        BigDecimal y = b.subtract(c);

        if(x.compareTo(y)==0){
            System.out.println("x与y相等");
        }
    }
}
//输出结果
x与y相等

2.3 BigDecimal 构造方法避坑

陷阱的产生:

  • double的构造方法的结果有一定的不可预知性,

    newBigDecimal(1.0)所创建的实际上等于0.1000000000000000055511151231257827021181583404541015625。

    因为0.1无法准确地表示为 double,传入到构造方法的值不会正好等于 0.1

  • String 构造方法是完全可预知的

​ 写入 newBigDecimal("0.1") 将创建一个 BigDecimal,它正好等于预期的 0.1

这里来填1.3中的坑,这里有两种方案

《阿里巴巴Java开发手册》1.4 OOP 规约中提到

【强制】 禁止使用构造方法BigDecimal(double)的方式把double值 转换为BigDecimal 对象

说明: BigDecimal(double) 存在精度损失风险,在精确计算或值比较的场景中,可能会导致业务逻辑出现异常。

如:BigDecimal g = new BigDecimal(0.1f); 实际存储值为:0.100000001490116119384765625

正例: 优先推荐入参为String 的构造方法,或使用BigDecimalvalueOf 方法。

此方法内部其实执行了DoubletoString, 而DoubletoStringdouble 的实际能表达的精度对尾数进行了截断。

BigDecimal good1 = new BigDecimal("0.1");
BigDecimal good2 = BigDecimal.valueOf(0.1);

①将BigDecimal(double) ==》BigDecimal(String)

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal(Double.toString(0.1));
        System.out.println("a=" + a);
    }
}
//输出结果
a=0.1

②使用BigDecimal类的valueOf 方法

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a =  BigDecimal.valueOf(0.1);
        System.out.println("a=" + a);
    }
}
//输出结果
a=0.1

2.4 BigDecimal 除法避坑

我们使用带有3个参数的divide 方法来填1.4中的坑

BigDecimal.divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 方法的具体使用我们再下一小节中再详细说

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.2");
        BigDecimal b = new BigDecimal("0.3");
		//这里就简单的看作四舍五入就行了
        System.out.println("a除以b等于:"+ a.divide(b, 2, RoundingMode.HALF_UP));

    }
}
//输出结果
a除以b等于:0.67

三、BigDecimal 常用方法

  • 常用构造方法

Java中的金钱陷阱

  • 常用方法

Java中的金钱陷阱

3.1 加法运算 add

public class BigDecimalDemo {
    public static void main(String[] args) {
       BigDecimal a = new BigDecimal(Double.toString(0.1));
       BigDecimal b = BigDecimal.valueOf(0.2);
        System.out.println("a + b ="+a.add(b));
    }
}
//输出结果
a + b =0.3

3.2 减法运算 subtract

public class BigDecimalDemo {
    public static void main(String[] args) {
       BigDecimal a = new BigDecimal(Double.toString(3.5));
       BigDecimal b = BigDecimal.valueOf(2.1);
        System.out.println("a - b ="+a.subtract(b));
    }
}
//输出结果
a - b =1.4

3.3 乘法运算 multiply

public class BigDecimalDemo {
    public static void main(String[] args) {
       BigDecimal a = new BigDecimal(Double.toString(2.5));
       BigDecimal b = BigDecimal.valueOf(3.26);
        System.out.println("a * b ="+a.multiply(b));
    }
}
//输出结果
a * b =8.150

3.4 除法运算 divide

BigDecimal除法可能出现不能整除的情况,比如 1.2/1.3,

这时会报错java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

这个之前也说过,这里呢再详细说说divide 方法

BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

  • divisor : 表示除数

  • scale: 表示小数点后保留位数

  • roundingMode: 表示舍入模式roundingMode是一个枚举类,有八种舍入模式

    我们以0.333 和-0.333保留2位小数为例,采用不同模式后得结果为

    --模式 --模式说明 图形说明
    UP 远离0的舍入模式【0.333-->0.34 -0.333 -->-0.34 Java中的金钱陷阱
    DOWN 接近0的舍入模式【0.333-->0.33 -0.333 -->-0.33 Java中的金钱陷阱
    CEILING CEILING英文是天花板的意思,可以理解为向”大“舍入【0.333-->0.34 -0.333 -->-0.33 Java中的金钱陷阱
    FLOOR FLOOR有地板的意思,可以理解为向”小“舍入【0.333-->0.33 -0.333 -->-0.34 Java中的金钱陷阱
    HALF_UP 向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则为向上舍入的舍入其实就是四舍五入>=0.5 入,<0.5的舍去
    HALF_DOWN 向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则为上舍入的舍入,其实就是五舍六入>0.5 的入,<=0.5 的舍去
    HALF_EVEN 向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则向相邻的偶数舍入【0.135-->0.14 0.125-->0.12
    UNNECESSARY 断言请求的操作具有精确的结果,因此不需要舍入
public class BigDecimalDemo {
    public static void main(String[] args) {
            BigDecimal numA = new BigDecimal("1");
            BigDecimal numB = new BigDecimal("-1");
            BigDecimal numC = new BigDecimal("3");
            // 保留两位小数,舍入模式为UP
            System.out.println("1/3保留两位小数(UP) = " + numA.divide(numC, 2, RoundingMode.UP));
            System.out.println("-1/3保留两位小数(UP) = " + numB.divide(numC, 2, RoundingMode.UP));
            // 保留两位小数,舍入模式为DOWN
            System.out.println("1/3保留两位小数(DOWN) = " + numA.divide(numC, 2, RoundingMode.DOWN));
            System.out.println("-1/3保留两位小数(DOWN) = " + numB.divide(numC, 2, RoundingMode.DOWN));
            // 保留两位小数,舍入模式为CEILING
            System.out.println("1/3保留两位小数(CEILING) = " + numA.divide(numC, 2, RoundingMode.CEILING));
            System.out.println("-1/3保留两位小数(CEILING) = " + numB.divide(numC, 2, RoundingMode.CEILING));
            // 保留两位小数,舍入模式为FLOOR
            System.out.println("1/3保留两位小数(FLOOR) = " + numA.divide(numC, 2, RoundingMode.FLOOR));
            System.out.println("-1/3保留两位小数(FLOOR) = " + numB.divide(numC, 2, RoundingMode.FLOOR));

            BigDecimal numD = new BigDecimal("1");
            BigDecimal numE = new BigDecimal("-1");
            BigDecimal numF = new BigDecimal("8");
            // 保留两位小数,舍入模式为HALF_UP
            System.out.println("1/8(=0.125)保留两位小数(HALF_UP) = " + numD.divide(numF, 2, RoundingMode.HALF_UP));
            System.out.println("-1/8(=0.125)保留两位小数(HALF_UP) = " + numE.divide(numF, 2, RoundingMode.HALF_UP));
            // 保留两位小数,舍入模式为HALF_DOWN
            System.out.println("1/8(=0.125)保留两位小数(HALF_DOWN) = " + numD.divide(numF, 2, RoundingMode.HALF_DOWN));
            System.out.println("-1/8(=0.125)保留两位小数(HALF_DOWN) = " + numE.divide(numF, 2, RoundingMode.HALF_DOWN));

            // 保留两位小数,舍入模式为HALF_EVEN
            System.out.println("0.54/4(=0.135)保留两位小数(HALF_EVEN) = " + new BigDecimal("0.54").divide(new BigDecimal("4"), 2, RoundingMode.HALF_EVEN));
            System.out.println("1/8(=0.125)保留两位小数(HALF_EVEN) = " + numE.divide(numF, 2, RoundingMode.HALF_EVEN));

            //UNNECESSARY,会报异常
            System.out.println("1/8(=0.125) = " + numE.divide(numF,  RoundingMode.UNNECESSARY));
        }

}
//输出结果
1/3保留两位小数(UP) = 0.34
-1/3保留两位小数(UP) = -0.34
1/3保留两位小数(DOWN) = 0.33
-1/3保留两位小数(DOWN) = -0.33
1/3保留两位小数(CEILING) = 0.34
-1/3保留两位小数(CEILING) = -0.33
1/3保留两位小数(FLOOR) = 0.33
-1/3保留两位小数(FLOOR) = -0.34
1/8(=0.125)保留两位小数(HALF_UP) = 0.13
-1/8(=0.125)保留两位小数(HALF_UP) = -0.13
1/8(=0.125)保留两位小数(HALF_DOWN) = 0.12
-1/8(=0.125)保留两位小数(HALF_DOWN) = -0.12
0.54/4(=0.135)保留两位小数(HALF_EVEN) = 0.14
1/8(=0.125)保留两位小数(HALF_EVEN) = -0.12
Exception in thread "main" java.lang.ArithmeticException: Rounding necessary

3.5 值转换

public class BigDecimalDemo {
    public static void main(String[] args) {
            BigDecimal a = new BigDecimal(Double.toString(2.3));
            BigDecimal b = new BigDecimal(10200000);

            System.out.println("BigDecimal转字符串:"+a.toString());
            System.out.println("BigDecimal转double:"+a.doubleValue());
            System.out.println("BigDecimal转float:"+a.floatValue());
            System.out.println("BigDecimal转长整型:"+b.longValue());
            System.out.println("BigDecimal转int:"+b.intValue());
    }

}
//输出结果
BigDecimal转字符串:2.3
BigDecimal转double:2.3
BigDecimal转float:2.3
BigDecimal转长整型:10200000
BigDecimal转int:10200000

3.6 绝对值 abs

public class BigDecimalDemo {
    public static void main(String[] args) {
            BigDecimal a = new BigDecimal(Double.toString(2.35));
            BigDecimal b = BigDecimal.valueOf(-2.35);

            System.out.println("a的绝对值是:" + a.abs());
            System.out.println("b的绝对值是:" + b.abs());
    }

}
//输出结果
a的绝对值是:2.35
b的绝对值是:2.35

3.7 等值比较

《阿里巴巴Java开发手册》第一章 1.4 OOP规约 中提到

【强制】 浮点数之间的等值判断,基本数据类型不能用==进行比较,包装数据类型不能用equals方法判断。

说明: 浮点数采用“尾数+阶码”的编码方式,类似于科学计数法的“有效数字+指数“ 的表示方式。

二级制无法精确表示大部分十进制小数,具体原理参考《码出高效,Java开发手册》

反例:
    float a = 1.0f - 0.9f;
    float b = 0.9f - 0.8 f;
	
	if(a==b){
        //预期进入此代码块,执行其他业务逻辑
        //但事实上a==b 的结果为false
    }
	Float x = Float.valueOf(a);
	Float y = Float.valueOf(b);
	if(x.equals(y)){
        // 预期进入此代码块,执行其他业务逻辑
        //但事实上x.equals(y)的结果为false
    }
正例:
    1)指定一个误差范围,若两个浮点数的差值在此范围之内,则认为是相等的。
    float a = 1.0f - 0.9f;
    float b = 0.9f - 0.8f;
	//10的-6次方
	float diff = 1e-6f;

	if(Math.abs(a-b)<diff){
        System.out.println("true");
    }
	2)使用BigDecimal定义值,再进行浮点数的运算操作。
    BigDecimal a = BigDecimal("0.1");
    BigDecimal b = BigDecimal("0.9");
    BigDecimal c = BigDecimal("0.8");

	BigDecimal x = a.subtract(b);
	BigDecimal y = b.subtract(c);

	/**
	*BigDecimal的等值比较应使用compareTo()方法,而不是equals() 方法。
	*说明:equals()方法会比较值和精度(1.0 与1.00 返回结果为false),
	*而compareTo()则会忽略精度。
	**/
	if (x.compareTo(y)==0){
        System.out.println("true");
    }

等值比较compareTo(BigDecimal val) 方法

a.compareTo(b)

  • -1:表示a小于b
  • 0:表示a等于b
  • 1:表示a大于b
public class BigDecimalDemo {
    public static void main(String[] args) {
            BigDecimal a = new BigDecimal("0.5");
            BigDecimal b = new BigDecimal("0.8");
            BigDecimal c = new BigDecimal("0.3");
            BigDecimal d = new BigDecimal("0.5");

            System.out.println("a与b比较结果:"+a.compareTo(b));
            System.out.println("a与c比较结果:"+a.compareTo(c));
            System.out.println("a与d比较结果:"+a.compareTo(d));
    }

}
//输出结果
a与b比较结果:-1
a与c比较结果:1
a与d比较结果:0

四、BigDecimal格式化

NumberFormat类的format()方法可以使用BigDecimal对象作为参数,

可以对超出16位有效数字的货币值,百分值,以及一般数值进行格式化控制

public class BigDecimalDemo {
    public static void main(String[] args) {
            NumberFormat money = NumberFormat.getCurrencyInstance(); //建立货币格式化引用
            NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用
            percent.setMaximumFractionDigits(3); //百分比小数点最多3位

            BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
            BigDecimal interestRate = new BigDecimal("0.008"); //利率
            BigDecimal interest = loanAmount.multiply(interestRate); //相乘

            System.out.println("贷款金额:" + money.format(loanAmount));
            System.out.println("利率:" + percent.format(interestRate));
            System.out.println("利息:" + money.format(interest));
    }

}
//输出结果
贷款金额:¥15,000.48
利率:0.8%
利息:¥120.00

五、BigDecimal 工具类

为了更加方便的使用BigDecimal 我们可以将其常用方法封装成工具类

package com.xiezhr.util;
import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 简化BigDecimal计算的小工具类
 */
public class BigDecimalUtil {

    /**
     * 默认除法运算精度
     */
    private static final int DEF_DIV_SCALE = 10;

    private BigDecimalUtil() {
    }

    /**
     * 提供精确的加法运算。
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算。
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.multiply(b2).doubleValue();
    }

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

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

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

    /**
     * 提供精确的类型转换(Float)
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static float convertToFloat(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.floatValue();
    }

    /**
     * 提供精确的类型转换(Int)不进行四舍五入
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static int convertsToInt(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.intValue();
    }

    /**
     * 提供精确的类型转换(Long)
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static long convertsToLong(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.longValue();
    }

    /**
     * 返回两个数中大的一个值
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 返回两个数中大的一个值
     */
    public static double returnMax(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.max(b2).doubleValue();
    }

    /**
     * 返回两个数中小的一个值
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 返回两个数中小的一个值
     */
    public static double returnMin(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.min(b2).doubleValue();
    }

    /**
     * 精确对比两个数字
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 如果两个数一样则返回0,如果第一个数比第二个数大则返回1,反之返回-1
     */
    public static int compareTo(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.compareTo(b2);
    }

}


六、避坑小结

  • 商业计算使用BigDecimal
  • 尽量使用参数类型为String的构造函数
  • BigDecimal都是不可变的,在进行每一步运算时,都会产生一个新的对象,所以在做加减乘除运算时千万要保存操作后的值

通过本期内容,你还会掉金钱陷阱里么?

本期内容到此就结束了,我们下期再见。(●'◡'●)

延伸 · 阅读

精彩推荐