主頁 > 後端開發 > Java中的金錢陷阱

Java中的金錢陷阱

2023-06-07 07:42:04 後端開發

前言

有多少小伙伴是被標題 騙 吸引進來的呢，我可不是標題黨，今天的文章呢確實跟”金錢“有關系，

但是我們說的不是過度追求金錢而掉入陷阱，而是要說一說在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都是不可變的，在進行每一步運算時，都會產生一個新的物件，所以在做加減乘除運算時千萬要保存操作后的值

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

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/554483.html

標籤：其他

上一篇：【技識訓累】Python中的PyTorch庫【一】

下一篇：返回列表

標籤雲
其他(160484) Python(38206) JavaScript(25478) Java(18205) C(15237) 區塊鏈(8270) C＃(7972) AI(7469) 爪哇(7425) MySQL(7234) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5873) 数组(5741) R(5409) Linux(5347) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4585) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2434) ASP.NET(2403) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) .NET技术(1983) 功能(1967) HtmlCss(1952) Web開發(1951) C++(1932) python-3.x(1918) 弹簧靴(1913) xml(1889) PostgreSQL(1879) .NETCore(1863) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Java中的金錢陷阱

    ### 前言 有多少小伙伴是被標題 ~~騙~~ 吸引進來的呢，我可不是標題黨，今天的文章呢確實跟”金錢“有關系。 但是我們說的不是過度追求金錢而掉入陷阱，而是要說一說在Java程式中，各種跟金錢運算有關的陷阱。 日常作業中我們經常會涉及到各種金額這樣**浮點數的運算**。 一旦涉及到金額的運算就必須 ......

    uj5u.com 2023-06-07 07:42:04 more
  • 【技識訓累】Python中的PyTorch庫【一】

    博客推行版本更新，成果積累制度，已經寫過的博客還會再次更新，不斷地琢磨，高質量高數量都是要追求的，工匠精神是學習必不可少的精神。因此，大家有何建議歡迎在評論區踴躍發言，你們的支持是我最大的動力，你們敢投，我就敢肝 ......

    uj5u.com 2023-06-07 07:41:56 more
  • 8-地圖可視化與seaborn可視化

    # 地圖可視化 basemap安裝和使用 區域縮放與繪圖 綜合案例：美國人口分布圖 # seaborn可視化 樣式與分布圖 分類圖 # basemap地圖繪制 地圖繪制也是資料可視化的一部分，常用的地圖繪制庫為basemap工具包，其為matplotlib的子包。本章將講解如何利用whl檔案在Pyt ......

    uj5u.com 2023-06-07 07:40:38 more
  • 演算法 in Golang：Recursion（遞回）

    # 演算法 in Golang：Recursion（遞回） ## 遞回演算法 ### 場景：在套娃中找到寶石 ### 可以這樣做 - while 沒找到： - if 當前項 is 寶石： - return 寶石 - else if 當前項 is 套娃： - 打開這個套娃 - if 當前項 is 寶石： ......

    uj5u.com 2023-06-07 07:39:52 more
  • JVM運行時資料區

    # JVM運行時資料區 ## 簡介 JVM運行時資料區包括：JVM堆疊（虛擬機堆疊），堆，方法區，本地方法堆疊，PC暫存器。大概的劃分就是堆疊和堆，以及一些其他的結構。重點在JVM堆疊，堆，方法區。JVM規范指出：方法區在邏輯上屬于堆，但是實際的具體的JVM中并不屬于堆的一部分。 在JVM堆疊中會發生GC和Er ......

    uj5u.com 2023-06-07 07:39:32 more
  • 20個Golang片段讓我不再健忘

    本文使用代碼片段的形式來解釋在 go 語言開發中經常遇到的小功能點，由于本人主要使用 java 開發，因此會與其作比較，希望對大家有所幫助。 ......

    uj5u.com 2023-06-07 07:39:21 more
  • Python 中 yeild 的用法

    本文包含以下四部分： > 1. yeild 介紹 > 2. yeild 案例 > 3. 簡單的例子對比yeild和常規函式 > 4. 復雜的例子說明yeild 與普通函式的差異 ### 1. yeild 介紹 yield 是 Python 的一個關鍵字，用于從一個函式中回傳一個生成器（generat ......

    uj5u.com 2023-06-07 07:39:16 more
  • 47基于java的養老院管理系統設計與實作

    基于java的養老院管理系統設計與實作；可適用于敬老院管理系統，老人管理系統，老人資訊管理系統，java養老院資訊系統，java敬老院資訊管理系統； ......

    uj5u.com 2023-06-07 07:39:12 more
  • java集成OpenAI的chatGpt功能

    一、開通OpenAI賬號 1.注冊OpenAI賬號 官網地址：https://openai.com/ 注意：提前準備好國外手機號，沒有的話用短信平臺購買手機號接收短信 2.購買國外手機號 地址：https://tiger-sms.com/ 我用支付寶充值了30多元（起充要30，加上手續費30多有點坑 ......

    uj5u.com 2023-06-07 07:33:27 more
  • Java革命性ORM框架之快速上手的Jimmer

    Jimmer是一款革命性的ORM框架，它的目標是提供一個簡單易用的API，幫助開發人員更加輕松地操作資料庫。Jimmer使用了Java 8的新特性，如Lambda運算式和Stream API，使得代碼更加簡潔、易讀。本文將詳細介紹Jimmer的基本用法，并提供一些Java代碼案例說明。 # 1. 什 ......

    uj5u.com 2023-06-06 15:25:39 more

Copyright © 2010-2020 有解無憂