Java 程序运行缓慢？

Question

如果“private int ggT(int a, int b)”中有这两行，我不明白为什么我的程序需要 0 秒到运行 >>> if (a < 0) a *= -1; if (b < 0 ) b *= -1;

如果我删除这两行，它需要超过 30 秒才能运行。我只想了解这两行的作用，因为我没有编写代码。而且我认为这两行是多余的。

顺便说一句，我猜我正在用 java 8.0 在 Netbeans 中编码。

这是整个程序：

public class Bruch {

    private int zaehler;
    private int nenner;
    
    public Bruch(int zaehler, int nenner){
        this.zaehler = zaehler;
        this.nenner = nenner;
        if (zaehler < 0 & nenner < 0) {
            this.nenner *= -1;
            this.zaehler *= -1;
        }
        kuerzeDich();
           
    }
           
    private int min(int a, int b) {
        if (a < b) return a;
        return b;
    }

    private int ggT(int a, int b) {
        if (a < 0) a *= -1;
        if (b <0 ) b *= -1;
    
        int ggTeiler = min(a, b);
        while (a%ggTeiler != 0 || b%ggTeiler != 0) {
           ggTeiler--;
        }
        return ggTeiler;
    }

    private void kuerzeDich() {
        int ggTeiler = ggT(zaehler, nenner);
        zaehler = zaehler / ggTeiler;
        nenner = nenner / ggTeiler;
    }

    @Override
    public String toString() {
        return String.valueOf(zaehler + "/" + nenner);
    }

    public Bruch kehrwert() {
        return new Bruch(nenner, zaehler);
    }

    public Bruch add(Bruch pOther) {
        int ggTeiler = ggT(nenner, pOther.nenner);
        int kgV = nenner * pOther.nenner / ggTeiler;
        int neuerZaehler = zaehler * (kgV/nenner) + pOther.zaehler * (kgV/pOther.nenner);
        return new Bruch(neuerZaehler, kgV);
    }

    public Bruch sub(Bruch pOther) {
        int ggTeiler = ggT(nenner, pOther.nenner);
        int kgV = nenner * pOther.nenner / ggTeiler;
        int neuerZaehler = zaehler * (kgV/nenner) - pOther.zaehler * (kgV/pOther.nenner);
        return new Bruch(neuerZaehler, kgV);
    }

    public Bruch mul(Bruch pOther) {
        int neuerzaehler = zaehler * pOther.zaehler;
        int neuernenner = nenner * pOther.nenner;
        return new Bruch(neuerzaehler, neuernenner);
    } 

    public Bruch div(Bruch pOther) {
        return new Bruch(zaehler,nenner).mul(pOther.kehrwert());
    }


    public static void main(String[] args) {
        Bruch b1 = new Bruch(1, 6);
        Bruch b2 = new Bruch(3, 4);
        System.out.println(b1.add(b2));
        System.out.println(b1.sub(b2));
       System.out.println(b1.mul(b2));
        System.out.println(b1.div(b2));
    }
}

Answer 1

我的假设是在对它们执行数学运算时，它会低于 0 然后分配给 zaehler nenner.
花费更多时间的原因是因为这个代码（模数）

int ggTeiler = min(a, b);
while (a%ggTeiler != 0 || b%ggTeiler != 0) {
     ggTeiler--;
}

x % y 总是等于 x % -y
您可以将第二个操作数的符号视为被忽略。 x % 5（与 x % -5 相同）。

-5 %  11 == -5
 5 % -11 ==  5
-5 % -11 == -5

假设其中之一是 -11 和 5。 -11 小于 5 然后分配给 ggTeiler.
现在，5 % -11 = 5 即 != 0 并且循环继续。
ggTeiler-- -> -11-1=-12.
5 % -12 = 5 始终保持 5，循环继续。
直到 ggTeiler 它从最小整数值变为最大整数值。参考 this
因此，从最大正整数值，它会得出一个值，其中 5 % ggTeiler != 0 和 -11 % ggTeiler != 0 在 ggTeiler = -1 时都变为假。
然后循环退出。

练习跟踪您的程序。您将了解每一行的作用。

Java 程序运行缓慢？

Java program runs slow?

java

netbeans