Java中精确计算百分比增量：避免整数除法与浮点精度陷阱

int a = 3;
int percentage = 50; // 代表50%
// 错误示例：直接将百分比作为整数进行除法
// int increase = a * (percentage / 100); // 50 / 100 = 0 (整数除法)
// a = a + increase; // 结果仍为3

int originalValue = 3;
int percent = 50; // 代表50%

// 计算百分比因子：将其中一个操作数转换为double
double percentageFactor = (double) percent / 100; // 50.0 / 100 = 0.5
System.out.println("百分比因子: " + percentageFactor); // 输出: 0.5

// 计算增量
double increaseAmount = originalValue * percentageFactor; // 3 * 0.5 = 1.5
System.out.println("增量: " + increaseAmount); // 输出: 1.5

// 计算最终值
double finalValue = originalValue + increaseAmount; // 3 + 1.5 = 4.5
System.out.println("最终值 (double): " + finalValue); // 输出: 4.5

int originalValue = 3;
int percent = 50;

// 使用1.0强制浮点运算
double percentageFactor = 1.0 * percent / 100; // 1.0 * 50 / 100 = 0.5
System.out.println("百分比因子: " + percentageFactor); // 输出: 0.5

double finalValue = originalValue * (1.0 + percentageFactor); // 3 * (1.0 + 0.5) = 4.5
System.out.println("最终值 (double): " + finalValue); // 输出: 4.5

int originalValue = 3;
double percentageFactor = 1.0 * 50 / 100; // 0.5
double calculatedValue = originalValue * (1.0 + percentageFactor); // 4.5

System.out.println("原始double结果: " + calculatedValue); // 输出: 4.5

// 错误示例：直接强制转换为int，会截断小数
int truncatedInt = (int) calculatedValue;
System.out.println("直接截断为int: " + truncatedInt); // 输出: 4 (在此例中碰巧正确，但如果结果是3.9999999999999996，则会是3)

// 推荐做法：添加一个小的偏移量来处理精度和舍入
// 如果希望四舍五入到最近的整数，可以加0.5然后向下取整
// 如果只是为了避免3.999...被截断为3，加0.1就足够
int roundedInt = (int) (calculatedValue + 0.1); // 4.5 + 0.1 = 4.6 -> (int)4.6 = 4
System.out.println("添加偏移量后转换为int: " + roundedInt); // 输出: 4

// 另一个例子：如果结果是3.9999999999999996
double problematicValue = 3.9999999999999996;
System.out.println("问题double值: " + problematicValue);
int problematicTruncated = (int) problematicValue;
System.out.println("问题值直接截断为int: " + problematicTruncated); // 输出: 3

int problematicRounded = (int) (problematicValue + 0.1); // 3.999... + 0.1 = 4.099... -> (int)4.099... = 4
System.out.println("问题值添加偏移量后转换为int: " + problematicRounded); // 输出: 4

public class PercentageCalculator {

    /**
     * 计算一个数值的百分比增量。
     *
     * @param baseValue 原始数值
     * @param percentage 增长的百分比 (例如，50代表50%)
     * @return 经过百分比增长后的整数值
     */
    public static int calculateIncreasedValue(int baseValue, int percentage) {
        // 1. 计算百分比因子，确保浮点除法
        // 例如：50% -> 0.5
        double percentageFactor = (double) percentage / 100.0;

        // 2. 计算增长后的精确值 (使用double)
        // 例如： baseValue = 3, percentageFactor = 0.5
        // 增长后的值 = 3 * (1 + 0.5) = 4.5
        double finalDoubleValue = baseValue * (1.0 + percentageFactor);

        // 3. 将double结果转换为int，并考虑浮点精度和截断问题
        // 添加一个小的偏移量，以确保正确的四舍五入或避免向下截断错误
        return (int) (finalDoubleValue + 0.1);
    }

    public static void main(String[] args) {
        int initialValue = 3;
        int percentIncrease = 50; // 50% 增长

        int result = calculateIncreasedValue(initialValue, percentIncrease);
        System.out.println("原始值: " + initialValue + ", 增长百分比: " + percentIncrease + "%");
        System.out.println("增长后的整数值: " + result); // 期望输出: 4

        int initialValue2 = 10;
        int percentIncrease2 = 25; // 25% 增长
        int result2 = calculateIncreasedValue(initialValue2, percentIncrease2);
        System.out.println("原始值: " + initialValue2 + ", 增长百分比: " + percentIncrease2 + "%");
        System.println("增长后的整数值: " + result2); // 期望输出: 13 (10 * 1.25 = 12.5 -> 13)

        int initialValue3 = 7;
        int percentIncrease3 = 10; // 10% 增长
        int result3 = calculateIncreasedValue(initialValue3, percentIncrease3);
        System.out.println("原始值: " + initialValue3 + ", 增长百分比: " + percentIncrease3 + "%");
        System.out.println("增长后的整数值: " + result3); // 期望输出: 8 (7 * 1.1 = 7.7 -> 8)
    }
}