Java中的金錢陷阱

来源:https://www.cnblogs.com/xiezhr/archive/2023/06/06/17461874.html
-Advertisement-
Play Games

### 前言 有多少小伙伴是被標題 ~~騙~~ 吸引進來的呢，我可不是標題黨，今天的文章呢確實跟”金錢“有關係。 但是我們說的不是過度追求金錢而掉入陷阱，而是要說一說在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 浮點數運算避坑

① 我們先來看看為什麼浮點數(也就是float 和double 關鍵字定義的數) 運算的時候精度會丟失？

我們直到電腦是以二進位的方式進行數據存儲的，在表示一個數字時，寬度時有限的。

十進位的 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 的構造方法，或使用BigDecimal 的 valueOf 方法。

此方法內部其實執行了Double 的toString, 而Double 的 toString 按double 的實際能表達的精度對尾數進行了截斷。

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 常用方法

  • 常用構造方法

構造方法

  • 常用方法

常用方法

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】 遠離0
    DOWN 接近0的舍入模式【0.333-->0.33 -0.333 -->-0.33】 近0模式
    CEILING CEILING英文是天花板的意思，可以理解為向”大“舍入【0.333-->0.34 -0.333 -->-0.33】 image-20230605230527632
    FLOOR FLOOR有地板的意思，可以理解為向”小“舍入【0.333-->0.33 -0.333 -->-0.34】 image-20230605230636060
    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都是不可變的，在進行每一步運算時，都會產生一個新的對象，所以在做加減乘除運算時千萬要保存操作後的值

通過本期內容，你還會掉金錢陷阱里麽？

本期內容到此就結束了，我們下期再見。(●'◡'●)


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 幫你梳理了一份前端知識架構圖
    > 隨著人工智慧技術的不斷發展，阿裡體育等IT大廠，推出的“樂動力”、“天天跳繩”AI運動APP，讓**雲上運動會、線上運動會、健身打卡、AI體育指導**等概念空前火熱。那麼，能否將這些在APP成功應用的場景搬上小程式，分享這些概念的紅利呢？本系列文章就帶您一步一步從零開始開發一個AI運動小程式，本 ...
  • 如何製作 Storybook Day 網頁上的 3D 效果？
    Storybook 剛剛達到了一個重要的里程牌：7.0 版本！為了慶祝，該團隊舉辦了他們的第一次用戶大會 - [Storybook Day](https://storybook.js.org/day)。為了更特別，在活動頁面中添加了一個視覺上令人驚嘆的 3D 插圖。 原文：[How we built ...
  • 【618備戰巡禮】“三高”之第一高--如何打造高可用系統
    我們經常會說互聯網“三高”，那什麼是三高呢？我們常說的三高，高併發、高可用、高性能，這些技術是構建現代互聯網應用程式所必需的。對於京東618備戰來說，所有的中台系統服務，無疑都是圍繞著三高來展開的。對於一個程式員，或多或少都能說出一些跟三高系統有關的技術點，而我本篇文章的目的，就是幫大家系統的梳理一... ...
  • 說說驗證碼功能的實現
    大家好，我是 god23bin，今天說說驗證碼功能的實現，相信大家都經常接觸到驗證碼的，畢竟平時上網也能遇到各種驗證碼，需要我們輸入驗證碼進行驗證我們是人類，而不是機器人。 ...
  • 演算法 in Golang：Breadth-first search（BFS、廣度優先搜索）
    # 演算法 in Golang：Breadth-first search # （BFS、廣度優先搜索） ## 最短路徑問題 Shortest-path problem - 從 A 到 F 點有多條路徑 ## 解決問題的演算法 Breadth-first Search（廣度優先搜索） 1. 將問題建模為圖 ...
  • 逍遙自在學C語言 | break-迴圈的中斷與跳轉
    ## 前言 在C語言中，`break`語句是一種控制流語句，它用於終止當前所在的迴圈結構（`for`、`while`、`do-while`）或者`switch`語句，從而跳出迴圈或者結束`switch`語句的執行。 ## 一、人物簡介 - 第一位閃亮登場，有請今後會一直教我們C語言的老師 —— 自在 ...
  • C++面試八股文：static和const的關鍵字有哪些用法?
    某日二師兄參加XXX科技公司的C++工程師開發崗位第7面： > 面試官：C++中，`static`和`const`的關鍵字有哪些用法? > > 二師兄：`satic`關鍵字主要用在以下三個方面：1.用在全局作用域，修飾的變數或者函數為靜態的，限制在本文件內使用。2.方法內修飾修飾靜態局部變數，在第一 ...
  • 演算法 in Golang：Quicksort（快速排序）
    # 演算法 in Golang：Quicksort（快速排序） ## Quicksort（快速排序） - 快速排序 O(nlog2^n)，比選擇排序要快 O(n²) - 在日常生活中經常使用 - 使用了 D & C 策略（分而治之） ## 使用 Quicksort 排序數組 - 不需要排序的數組（也就 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類