blocks|key|734436|text|这里有趣的问题是编译器如何翻译开关(可能像哈希表，或者结果可以类似于if-else结构)。它还可以根据输入进行各种优化(如果已知的话)。但是，这是编译器依赖的，我知道的任何规范中都没有定义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|734437|所以，我不能给你答案，但我可以告诉你，如果你想改进你的测试，你可以给它输入7。这将使它通过所有的测试，直到返回一个答案，如果开关是优化的，它会给你更好的结果，如果它是一个假设-如果它会有相似的结果。只是不要硬编码7，这样编译器就不会提前知道它，使用parseint之类的方法从字符串中获取它。|734438|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The interesting question here is how the compiler translates switch (might be like a hash table or the results can be similar to an if-else structure). It can also do all kinds of optimizations based on the input (if it's known). However, this is compiler dependent and is not defined in any spec I'm aware of.

So, I can't give you the answer, but I can tell you that if you want to refine your test even more you can always give it an input of 7. This will make it go through all of the tests until returning an answer, and if the switch is optimized it will give you better results, if it's just like an if-else it will have similar results. Just don't hard code the 7 so that the compiler doesn't know it ahead of time, use something like parseint to get it from a string.

blocks|key|735103|text|开关应该更快，只要看看字节码就够了|type|unstyled|depth|inlineStyleRanges|entityRanges|data|735104|+++TABLESWITCH
++++++1:+L1
++++++2:+L2
++++++3:+L3
++++++4:+L4
++++++5:+L5
++++++6:+L6|code-block|syntax|javascript|735105|以确保这是一项特殊的行动。在现实生活中，由于JVM的优化，可能没有什么不同。但是如果我们用-Xint+(interepret模式)运行您的代码，那么差别应该很明显，在我的PC上，它是63比93+(ms)，赞成切换。|735106|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Switch is supposed to be faster, it's enough to look at the bytecode

<pre><code> TABLESWITCH
 1: L1
 2: L2
 3: L3
 4: L4
 5: L5
 6: L6
</code></pre>

to see that it is a special operation. In real life there may be no difference because of JVM optimizations. But if we run your code with -Xint (interepret only mode) then the difference should be evident, on my PC it is 63 to 93 (ms) in favour of switch.

blocks|key|747945|text|这在某种程度上是不公平的。大部分CPU时间将用于处理模块操作：i+%25+7。Modulo+--即使是在最新的最大型CPU上--也非常慢，执行起来可能比正在尝试测试的if()或switch()实现要长20倍。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|747946|此外，有两种不同的方法可以优化开关语句。一种是查找表，它用于像您提出的那种顺序的情况。另一种方法是在适当的情况下使用搜索分区树。当情况稀疏时，就会发生这种情况，如下面的示例：|BOLD|747947|switch+(someInt)+{
++++case+0:++...+break;
++++case+10:++...+break;
++++case+102:++...+break;
++++case+6543:++...+break;
++++case+19303:++...+break;
++++case+19305:++...+break;
++++//+and+so+forth...
}|code-block|syntax|javascript|747948|大多数编译器将使用一个未展开的分区树来找到正确的大小写，在长开关上，这会提供非常好的avg和最坏情况下的跳转来找到正确的情况。生成的伪代码如下所示：|747949|if+(someInt+>=+6543)+{
++++if+(someInt+>=+19303)+{
++++++++//+continue+tree+search,+etc.
++++}
++++else+if+(someInt==6543)+{}
}
else+if+(someInt+>=+0)+{
++++if+(someInt+>=+10)+{
++++++++//+continue+tree+search,+etc.
++++}
++++else+if+(someInt+==+0)+{}+
}
else+{
++++//+default+case+handler...
}|747950|正如这里所示，对于6-8个案例来说，这并没有多大帮助，但是如果您切换了一个可能是50%2B的案例，那么它将是非常有用的。线性搜索将有O(n)+(50个条件最差，25个avg)，而分区树版本将接近sqrt(n)+(8-9个条件最差，5-7个avg，取决于编译器的选择)。|747951|entityMap^0|V|5|0|1M|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|H]]|D|@]|E|$]]|$1|I|3|J|5|K|7|11|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|12|8|@]|D|@]|E|$]]|$1|P|3|Q|5|K|7|13|8|@]|D|@]|E|$L|M]]|$1|R|3|S|5|6|7|14|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|U|$]]

This is an unfair comparison to some extent. Most of the CPU time will be spent processing the modulo operation: <code>i % 7</code>. Modulo even on latest greatest CPUs is extremely slow and probably takes 20x longer to execute than either the if() or switch() implementations you're trying to benchmark.

Furthermore, there are two different ways that switch statements can be optimized. One is by lookup table, which is used in sequential cases like the one you've put forth. The other way is by using search partition trees, where appropriate. This happens when the cases are sparse, such as in the following example:

<pre><code>switch (someInt) {
 case 0: ... break;
 case 10: ... break;
 case 102: ... break;
 case 6543: ... break;
 case 19303: ... break;
 case 19305: ... break;
 // and so forth...
}
</code></pre>

Most compilers will use an unrolled partition tree to find the correct case, which on long switches gives very good avg and worst-case jumps needed to hit the right one. The resulting pseudo-code would be something like this:

<pre><code>if (someInt &gt;= 6543) {
 if (someInt &gt;= 19303) {
 // continue tree search, etc.
 }
 else if (someInt==6543) {}
}
else if (someInt &gt;= 0) {
 if (someInt &gt;= 10) {
 // continue tree search, etc.
 }
 else if (someInt == 0) {} 
}
else {
 // default case handler...
}
</code></pre>

It doesn't really help much with just 6-8 cases as shown here, but if you had a switch with perhaps 50+ cases then it can be really helpful. A linear search would have O(n) (50 conditions worst, 25 avg), while the partition tree version would be close to sqrt(n) (8-9 conditions worst, 5-7 avg, depending on compiler choices).

blocks|key|747962|text|由于您的代码可能会或可能不会根据JIT的智能程度而被消除，所以您可能已经确定if语句比开关更容易消除。这并不奇怪，因为很多语句更有可能被删除，例如断言和调试检查。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|747963|entityMap^0|12|2|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

As you have code which may or may not be eliminated based on how smart the JIT is, you may have determined that the <code>if</code> statements are easier to eliminate than a switch. This is not surprising as many if statements are more likely to be eliminated e.g. assertions and debug checks.

I was curious as to the speed on <code>switch</code>, believing that it was "very" fast, but I have a test case that seems to show a single switch is about as fast as about 4 <code>if</code> tests, when I expected (no solid reason) it to be as fast as 1 test. Here's the two methods I wrote to compare <code>switch</code> with <code>if</code>:

<pre><code>public static int useSwitch(int i) {
 switch (i) {
 case 1: return 2;
 case 2: return 3;
 case 3: return 4;
 case 4: return 5;
 case 5: return 6;
 case 6: return 7;
 default: return 0;
 }
}

public static int useIf(int i) {
 if (i == 1) return 2;
 if (i == 2) return 3;
 if (i == 3) return 4;
 if (i == 4) return 5;
 if (i == 5) return 6;
 if (i == 6) return 7;
 return 0;
}
</code></pre>

Here's my testing code:

<pre><code>long x = 0;
for (int i = 0; i &lt; 999999; i++)
 x += useIf(i % 7); // I use "x" so calls won't get optimized out
</code></pre>

And another identical loop for <code>useSwitch()</code>

On my machine these loops take about the same time to complete, which was a surprise. 
I arrived at the number of ifs as "4", because that's the average given the input range (I think). 
If I reduce the number of logic options, the <code>if</code> version is noticeably faster.

 
My question is:

Is it that <code>switch</code> actually isn't that fast, or is this an "unfair" test in some way?

Switch seems slower than if

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我对switch上的速度很好奇，认为它“非常”快，但我有一个测试用例，它似乎表明一个开关大约和4个if测试一样快，而我预计(没有确凿的理由)它会和一个测试一样快。下面是我为比较switch和if而编写的两种方法public static int useSwitch(int i) {    switch (i) {   ...

问开关似乎比如果
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问开关似乎比如果EN