Java 级联if-else语句和嵌套if语句之间是否存在性能差异

级联if-else语句之间是否存在性能差异

if（i>c20）{
// ...
}如果（i>c19），则为else{
// ...
}如果（i>c18），则为else{
// ...
}如果（i>c17），则为else{
// ...
}否则，如果（i>c16）{
// ...
}如果（i>c15），则为else{
// ...
}如果（i>c14），则为else{
// ...
}如果（i>c13），则为else{
// ...
}如果（i>c12），则为else{
// ...
}如果（i>c11），则为else{
// ...
}否则，如果（i>c10）{
// ...
}如果（i>c9），则为else{
// ...
}如果（i>c8），则为else{
// ...
}如果（i>c7），则为else{
// ...
}否则，如果（i>c6）{
// ...
}如果（i>c5），则为else{
// ...
}如果（i>c4），则为else{
// ...
}否则，如果（i>c3）{
// ...
}否则，如果（i>c2）{
// ...
}否则，如果（i>c1）{
// ...
}否则如果（i>c0）{
// ...
}否则{
// ...
}

和嵌套的if语句，如：

if（i>c10）{
如果（i>c15）{
如果（i>c18）{
如果（i>c19）{
如果（i>c20）{
// ...
}否则{
// ...
}
}否则{
//...
}
}否则{
如果（i>c17）{
// ...
}否则{
// ...
}
}
}否则{
如果（i>c13）{
如果（i>c14）{
// ...
}否则{
// ...
}
}否则{
如果（i>c12）{
// ...
}否则{
// ...
}
}
}
}否则{
如果（i>c5）{
如果（i>c8）{
如果（i>c9）{
//...
}否则{
//...
}
}否则{
如果（i>c7）{
// ...
}否则{
// ...
}
}
}否则{
如果（i>c3）{
如果（i>c4）{
// ...
}否则{
// ...
}
}否则{
如果（i>c2）{
// ...
}否则{
如果（i>c0）{
如果（i>c1）{
// ...
}
}否则{
// ...
}
}
}
}
}

如果存在差异，一个比另一个快的原因是什么？一种形式是否会导致：更好的JIT编译、更好的缓存策略、更好的分支预测、更好的编译器优化等。？我对

Java

中的性能特别感兴趣，但我想知道它在其他语言（如C/C++、C#等）中的相似之处或不同之处

i

的不同分布、检查的范围和/或不同数量的

（如果
语句）会如何影响结果


这里的值
c0
到
c20
顺序严格递增，因此产生了愤怒。例如：

c0=0；
c1=10；
c2=20；
c3=30；
c4=40；
c5=50；
c6=60；
c7=70；
c8=80；
c9=90；
c10=100；
c11=110；
c12=120；
c13=130；
c14=140；
c15=150；
c16=160；
c17=170；
c18=180；
c19=190；
c20=200；

或

c0=0；
c1=1；
c2=2；
c3=3；
c4=4；
c5=5；
c6=6；
c7=7；
c8=8；
c9=9；
c10=10；
c11=11；
c12=12；
c13=13；
c14=14；
c15=15；
c16=16；
c17=17；
c18=18；
c19=19；
c20=20；
首先，让我们分析您的第一个代码片段

if (i > 0) {
// ...
} else if (i > 1) {
// ...
} else if (i > 2) {
//...

如果
条件符合以下条件，则所有这些条件均无意义：

如果
i
不大于
0
，则等于或小于
0
因此，您的
else if
条件应该具有这些值（即。
等于或小于
0
）

现在，让我们分析第二段代码：

if (i > 10) {
    if (i > 15) {
        if (i > 18) {
           //...

如您所见，如果
i
大于
10
，则第二个
if
条件
肯定会被评估，如果第二个是真的，第三个
一个肯定会被评估

因此，你是在比较苹果和桔子

如果分支相同，则性能应该没有任何差异。
有两个不同的因素在性能中起主要作用

算法的
暂时忘掉CPU如何工作的变幻莫测。想象一下这个代码：

for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        for (int k = 0; k < n; k++) {
            doSomething();
        }
    }
}

for（int i=0；i

doSomething
的性能可以而且可能会有很大的差异，即使这是一项非常简单的工作（嘿，热点编译是一件事！），但即使如此，如果
n
为10，它也会运行
doSomething
一千次。如果
n
为11，则
doSomething
将运行1331次。如果我们在x轴和y轴上绘制一个带有
n
的图表“doSomething调用的频率”，它将看起来像
y=x^3

这是一张增长非常快的图表。即使
doSomething
速度很快，或者性能非常不规则，对于一些足够大的
n
值，性能也将非常糟糕，这仅仅是因为我们在这里进行了大量的循环

对于一些足够大的值，关键字是。这意味着最终该代码的核心性能特征（
O（n^3）
）将是唯一相关的因素

但是一个CPU可以在瞬间循环1331次，如果
n
很小，那么它的3个循环深度与
doSomething
相比就显得微不足道了。当‘n’变得如此之大时，你所做的循环的绝对数量确保了这将是缓慢的，无论在剂量测量中发生什么？这取决于你的CPU。但这终究会发生

让我换一种说法：如果我们制作一个不同的图表，图表x轴=n，y轴=专用CPU在计算过程中花费的毫秒，那么聊天将
if (i > 0) {
// ...
} else if (i > 1) { 
// ...
} else if (i > 2) {
// ...
} else if (i > 3) {
// ...
} else if (i > 4) {

if (i > 10) {
    if (i > 15) {
        if (i > 18) {
            if (i > 19) {
                if (i > 20) {

 if (i>10 && i>15 && i>18 && i>19 && i>20){ // note i >10 && i< upperbound instead
 }