Java编译优化与性能 publicstaticvoidmain（字符串[]args）{ 双[]盒； 框=新的双[{20,10,5,40,20,41,41,2,6,7,3,4,5,6,23,34,7,8,2}； 双重=0； 双正态=0； 双重=0； 总成本加倍； 双a=0； 双b=0； int repeatCount=0； 对于（int i=1；i最重） 最重=盒子[i]； } 用于（双元素：框）{ 如果（元素==最重）{ repeatCount=repeatCount+1； } } System.out.println（“计数：+repeatCount”）； 对于（int j=0；j

，正确性总是比性能更重要

不知道为什么它在寻找最重的盒子时会忽略第一个盒子

你可以减少代码，但你最大的问题是你的代码运行的时间不够长，无法通过JIT编译，即使这样，与Java的启动成本相比，它也微不足道

简而言之，我不会担心性能，除非你的程序持续几百毫秒

顺便说一句，你可以使用一个循环，这将使代码更短，但就像我说的，在这种情况下不会有太大的区别

我可以这样写

 public static void main(String[] args) {
     double [] boxes;
        boxes = new double[]  {20, 10, 5, 40, 20, 41, 41, 2, 6, 7, 3, 4, 5, 6, 23, 34, 7, 8, 2, 2};
        double heaviest = 0;
        double normal = 0;
        double heavy = 0;
        double totalCost;
        double a = 0;
        double b = 0;
        int repeatCount=0;

        for (int i = 1; i < boxes.length; i++) {
            if (boxes[i] > heaviest)
                heaviest = boxes[i];
        }

        for(double element: boxes) {
            if(element==heaviest) {
                repeatCount = repeatCount+1;
            }
        }

        System.out.println("Count :" +repeatCount);

        for (int j =0; j<boxes.length; j++) {
            if (boxes[j] < heaviest) {
                a = boxes[j] * 2;
                normal = normal+a;
            } else {
                b =  (boxes[j] * 3.5);
                heavy = heavy+b;
            }
        }
        totalCost = normal+heavy;
        System.out.println("total cost of the insuranse is  "+ totalCost);
    }

注意：只有一个循环。你可以一边计算计数和总和

double[] boxes = {20, 10, 5, 40, 20, 41, 41, 2, 6, 7, 3, 4, 5, 6, 23, 34, 7, 8, 2, 2};
double heaviest = -1;
int count = 0;
double sum = 0;
for (double box : boxes) {
    sum += box;
    if (box > heaviest) {
        count = 1;
        heaviest = box;
    } else if (box == heaviest) {
        count++;
    }
}

// double total = sum * 2 - heaviest * count * 2 + heaviest * count * 3.5;
double total = sum * 2 + heaviest * count * 1.5;
System.out.println("total: " + total);

这是根据您的知识编写的代码，但有一点是固定的。您不需要使用

i

，也不需要将结果存储在

a

或

b

中，而是可以使用

+=

操作符

---

也就是说，使用双d1==双d2是危险的。我不建议直接使用它们。读一读文章或。实际上，我建议你两者都读。

当你从数组中取最大的元素时，你可以尝试按降序对数组排序。因此，你将得到第一个元素来执行你所说的t问。你已经计算出所有循环都有相同的形式，试着看看你是否可以只使用一个循环（不看mu答案；）是的，他们可以根据你的答案，但是我不想过度修改代码，这个答案比StackOverflow更适合CodeReview。“一如既往，正确性比性能更重要。”……你确定“永远”吗？“J.弗兰·萨·奥斯萨瓦尔，你喜欢一个错误的系统，但它很快，或者是一个正确但速度足够快的系统。注意：我认为一个系统不够快，是不正确的，这是我的结论。）也有一些例外情况，比如轻量级性能监视器，它们只是一个估计值。有意义的是，“正确性”一开始我并没有这样想。+1.别忘了，减少代码并避免迭代或for循环本身是一个巨大的性能提升。我自己本来打算在一个for循环中发布一个类似的代码，并注意到您已经做了同样的事情。当您已经知道数据的方向时，总是会有为了避免额外的代码。请定义“工作”是什么意思……我不知道你的程序是否打算每天打印一次，或者这种行为是否不正确；）……更严重的是，它实际上做了它应该做的事情，只是速度非常慢。我们可以肯定地说程序坏了，但我们真的可以把这个问题归类为一个问题吗“功能”问题考虑到它行使相同的功能？

public static void main(String[] args) {
    double [] boxes = new double[]  {20, 10, 5, 40, 20, 41, 41, 2, 6, 7, 3, 4, 5, 6, 23, 34, 7, 8, 2, 2};
    double heaviest = 0;
    double normal = 0;
    double heavy = 0;
    double totalCost;
    int repeatCount=0;

    for (double d : boxes) {
        heaviest = Math.max (boxes[i], heaviest);
    }

    for (double d : boxes) {
        if(d == heaviest) {
            repeatCount++;
        }
    }
    System.out.println("Count: " + repeatCount);

    for (double d : boxes) {
        if (d == heaviest) {
            heavy += d * 2.0;       
        } else {
            heavy += d * 3.5;
        }
    }
    totalCost = normal+heavy;

    System.out.println("Total cost of the insuranse is: " + totalCost);
}