blocks|key|214319|text|这在Java中并不是更高效。在可以重载增量/减量运算符的语言中，它可以更有效，但在其他情况下，性能完全相同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214320|x%2B%2B和%2B%2Bx的不同之处在于，x%2B%2B返回x*递增前的值，而%2B%2Bx返回递增后x的值。在代码生成方面，两者弥补了完全相同数量的指令，至少当你可以互换使用它们时(如果你不能互换使用它们，你不应该担心哪一个更快，你应该选择你需要的)。唯一的区别是增量指令放在哪里。|offset|length|style|CODE|214321|在C%2B%2B中，类可以重载前缀(%2B%2Bx)和后缀(x%2B%2B)运算符。在处理重载它们的类型时，使用前缀运算符几乎普遍更快，因为后缀运算符的语义将返回对象的副本，即使您不会使用它，而前缀运算符可以简单地返回对修改后的对象的引用(天知道C%2B%2B开发人员更喜欢返回引用而不是副本)。这可能是认为%2B%2Bx优于x%2B%2B的一个原因:如果你养成了使用%2B%2Bx的习惯，当你切换到C%2B%2B时，你可以省去一些轻微的性能问题。但仅在Java上下文中，两者是完全等效的。|214322|就像上面注释中的pst一样，我从不使用x%2B%2B或%2B%2Bx的返回值，如果您从来没有使用过这两个返回值，那么您可能应该坚持使用您喜欢的返回值。|214323|entityMap^0|0|0|3|4|3|F|3|K|1|T|3|11|1|0|E|3|M|3|3U|3|3Z|3|4G|3|0|J|3|N|3|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]|$D|X|E|Y|F|G]|$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1C|8|@$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|M|$]]

It's not more efficient in Java. It can be more efficient in languages where the increment/decrement operators can be overloaded, but otherwise the performance is exactly the same.

The difference between <code>x++</code> and <code>++x</code> is that <code>x++</code> returns the value of <code>x</code> before it was incremented, and <code>++x</code> returns the value of <code>x</code> after it was incremented. In terms of code generation, both make up for the exact same number of instructions, at least when you can use either interchangeably (if you can't use them interchangeably, you shouldn't be worrying about which one is faster, you should be picking the one you need). The only difference is where the increment instruction is placed.

In C++, classes can overload both the prefix (<code>++x</code>) and postfix (<code>x++</code>) operators. When dealing with types that overload them, it is almost universally faster to use the prefix operator because the semantics of the postfix operator will return a copy of the object as it was before the increment, even when you wouldn't use it, while the prefix operator can simply return a reference to the modified object (and God knows C++ developers prefer to return references rather than copies). This could be a reason to consider <code>++x</code> superior to <code>x++</code>: if you gain the habit of using <code>++x</code> you could save yourself some slight performance trouble when/if you switch to C++. But in the context of Java only, both are absolutely equivalent.

Much like pst in the comments above, I never use the return value of <code>x++</code> or <code>++x</code>, and if you never do either, you should probably just stick to the one you prefer.

blocks|key|214131|text|出于好奇，您可以检查生成的字节码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214132|此程序：|214133|public+static+void+main(String+args[])+{
++++int+i+=+1;+//bytecode+0,+1
++++i%2B%2B;+//bytecode+2
++++%2B%2Bi;+//bytecode+5
++++int+a+=+%2B%2Bi;+//bytecode+8,+11,+12
++++int+b+=+i%2B%2B;+//bytecode+13,+14,+17
}|code-block|syntax|javascript|214134|生成以下字节码：|214135|++public+static+void+main(java.lang.String[]);
++++Code:
+++++++0:+iconst_1
+++++++1:+istore_1
+++++++2:+iinc++++++++++1,+1
+++++++5:+iinc++++++++++1,+1
+++++++8:+iinc++++++++++1,+1
++++++11:+iload_1
++++++12:+istore_2
++++++13:+iload_1
++++++14:+iinc++++++++++1,+1
++++++17:+istore_3
++++++18:+return|214136|因此您可以看到，从字节码的角度来看，前缀运算符和后缀运算符是完全相同的(除了操作的顺序)。|214137|如果JIT编译了你的那部分代码，那么所有的赌注都失效了。例如，上面的代码可以编译为no-op，因为它没有副作用。|214138|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Out of curiosity, you can check the generated bytecode.

This program:

<pre><code>public static void main(String args[]) {
 int i = 1; //bytecode 0, 1
 i++; //bytecode 2
 ++i; //bytecode 5
 int a = ++i; //bytecode 8, 11, 12
 int b = i++; //bytecode 13, 14, 17
}
</code></pre>

generates the following bytecode:

<pre><code> public static void main(java.lang.String[]);
 Code:
 0: iconst_1
 1: istore_1
 2: iinc 1, 1
 5: iinc 1, 1
 8: iinc 1, 1
 11: iload_1
 12: istore_2
 13: iload_1
 14: iinc 1, 1
 17: istore_3
 18: return
</code></pre>

So you can see that pre and post fix operators are strictly identical from a bytecode perspective (apart from the order of the operations).

If and when the JIT compiles that part of your code, all bets are off. For example, the code above, as is, could be compiled as a no-op because it has no side effects.

blocks|key|3071036|text|问题的真相是，在PDP-11上，甚至在VAX上，*x%2B%2B在C上比*%2B%2Bx快，因为它编译成单条指令(自动递增寄存器延迟)。同样，*--x比*x--更快。如果编译器仍然生成该指令，则使用不带解引用的任何一种形式只会在一种情况下比在另一种情况下更快，这将是浪费的，因为仍然会发生解引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3071037|那些日子已经一去不复返了。|3071038|entityMap^0|O|4|W|4|1R|4|1W|4|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

The truth of the matter is that <code>*x++</code> was faster than <code>*++x</code> in C on a PDP-11, and maybe a VAX, because it compiled to a single instruction (autoincrement register deferred). Similarly <code>*--x</code> was faster than <code>*x--</code>. Using either form without the dereference would only be faster in one case rather than the other if the compiler still generated that instruction, which would have been wasteful because the dereference would still have occurred.

Those days are long gone.

During a programming class, the professor was teaching us about <code>x++</code> and <code>++x</code>, with x being an integer.

He said that in the scenario we are able to just put either <code>x++</code> or <code>++x</code>, <code>++x</code> is more efficient (by little, but still, in theory, more efficient nonetheless).

But I forgot why. Anyone knows? This was with Java.

Is ++x more efficient than x++ in Java?

编译器

Java

在编程课上，教授教我们关于x++和++x的知识，其中x是一个整数。他说，在这种情况下，我们可以只使用x++或++x，++x更有效(虽然有点，但在理论上仍然更有效)。，但是我忘了为什么。有人知道吗？这是用Java实现的。

问在Java中，++x比x++更有效吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，++x比x++更有效吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，++x比x++更有效吗？
EN