优化Java代码：使用除法和取模简化找零计算-java教程-PHP中文网

优化Java代码：使用除法和取模简化找零计算

DDD

发布： 2025-08-21 18:34:01

原创

409人浏览过

优化java代码：使用除法和取模简化找零计算

本文旨在提供一种更简洁高效的Java代码实现找零计算功能的方法。通过使用除法和取模运算，可以避免冗长的while循环，显著缩短代码长度并提高程序性能。文章将详细介绍如何利用这两种运算直接计算出各种面额的货币数量，并提供完整的代码示例和必要的解释。

简化找零计算逻辑

原始代码使用了多个while循环来计算各种面额的货币数量，这种方法效率较低且代码冗长。一种更优的解决方案是使用除法（/）和取模（%）运算符。

除法运算符可以用来计算给定金额中包含特定面额货币的最大数量。例如，要计算金额geld（以分为单位）中包含多少个2欧元（200分）的硬币，可以使用以下代码：

int numberOf2Euros = (int) (geld / 200);

登录后复制

取模运算符可以用来计算在提取了所有特定面额的货币后，剩余的金额。例如，在计算出2欧元硬币的数量后，可以使用以下代码更新剩余金额：

立即学习“Java免费学习笔记（深入）”；

geld = geld % 200;

登录后复制

通过结合使用除法和取模运算符，可以避免使用while循环，从而简化代码并提高效率。

代码小浣熊

代码小浣熊是基于商汤大语言模型的软件智能研发助手，覆盖软件需求分析、架构设计、代码编写、软件测试等环节

查看详情

代码示例

下面是一个使用除法和取模运算符简化找零计算的Java代码示例：

public class ChangeCalculator {

    public static void rueckgaberechner(double geld) {
        System.out.println("Rueckgeld: ");

        int numberOf2Euros = (int) (geld / 200);
        geld = geld % 200;
        if (numberOf2Euros > 0) {
            System.out.println(numberOf2Euros + " mal 2 Euro");
        }

        int numberOf1Euros = (int) (geld / 100);
        geld = geld % 100;
        if (numberOf1Euros > 0) {
            System.out.println(numberOf1Euros + " mal 1 Euro");
        }

        int numberOf50Cents = (int) (geld / 50);
        geld = geld % 50;
        if (numberOf50Cents > 0) {
            System.out.println(numberOf50Cents + " mal 50 Cent");
        }

        int numberOf20Cents = (int) (geld / 20);
        geld = geld % 20;
        if (numberOf20Cents > 0) {
            System.out.println(numberOf20Cents + " mal 20 Cent");
        }

        int numberOf10Cents = (int) (geld / 10);
        geld = geld % 10;
        if (numberOf10Cents > 0) {
            System.out.println(numberOf10Cents + " mal 10 Cent");
        }

        int numberOf5Cents = (int) (geld / 5);
        geld = geld % 5;
        if (numberOf5Cents > 0) {
            System.out.println(numberOf5Cents + " mal 5 Cent");
        }

        int numberOf2Cents = (int) (geld / 2);
        geld = geld % 2;
        if (numberOf2Cents > 0) {
            System.out.println(numberOf2Cents + " mal 2 Cent");
        }

        int numberOf1Cents = (int) geld;
        if (numberOf1Cents > 0) {
            System.out.println(numberOf1Cents + " mal 1 Cent");
        }
    }

    public static void main(String[] args) {
        rueckgaberechner(388); // 示例：计算3.88欧元的找零
    }
}

登录后复制

这段代码清晰地展示了如何使用除法和取模运算来计算各种面额的货币数量，避免了使用多个while循环。

使用枚举和Stream API进一步优化

为了使代码更具可读性和可维护性，可以使用枚举类型来表示不同的货币面额，并使用Java 8的Stream API进行更优雅的计算。

import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.stream.Collectors;

public class ChangeCalculator {

    enum EuroDenominations {
        ONE_CENT_COIN(1, "1¢"),
        TWO_CENT_COIN(2, "2¢"),
        FIVE_CENT_COIN(5, "5¢"),
        TEN_CENT_COIN(10, "10¢"),
        TWENTY_CENT_COIN(20, "20¢"),
        FIFTY_CENT_COIN(50, "50¢"),
        ONE_EURO_COIN(100, "€1"),
        TWO_EURO_COIN(200, "€2");

        private final int cents;
        private final String symbol;

        EuroDenominations(int cents, String symbol) {
            this.cents = cents;
            this.symbol = symbol;
        }

        public int cents() {
            return cents;
        }

        public String symbol() {
            return symbol;
        }
    }

    public static Map<EuroDenominations, Integer> rueckgaberechner(double geld) {
        AtomicReference<Double> atomicGeld = new AtomicReference<>(geld);
        return Arrays.stream(EuroDenominations.values())
                .sorted(Comparator.comparing(EuroDenominations::cents).reversed())
                .collect(Collectors.toMap(Function.identity(), v -> {
                            double g = atomicGeld.get();
                            int i = (int) (g / v.cents());
                            atomicGeld.set(g % v.cents());
                            return i;
                        },
                        (a, b) -> a,
                        LinkedHashMap::new));
    }

    public static void main(String[] args) {
        Map<EuroDenominations, Integer> rueckgaberechner = rueckgaberechner(388);
        System.out.println(rueckgaberechner);

        System.out.println("\nPretty print:");

        rueckgaberechner.entrySet().stream()
                .filter(entry -> entry.getValue() != 0)
                .forEach(entry -> System.out.printf("%d mal %s\n", entry.getValue(), entry.getKey().symbol()));
    }
}

登录后复制

这个例子使用了枚举EuroDenominations来定义货币面额，并使用Stream API对枚举值进行排序和计算。AtomicReference用于在lambda表达式中修改geld的值。LinkedHashMap用于保持输出的顺序。

注意事项

数据类型： 在进行货币计算时，应使用int或long类型来表示以分为单位的金额，以避免浮点数精度问题。如果必须使用double类型，请注意进行适当的舍入处理。
错误处理： 在实际应用中，应添加错误处理机制，例如验证输入金额是否为正数。
性能： 对于高并发场景，可以考虑使用缓存来存储常用的找零结果，以提高性能。