在 java 中 x + + 和 + + x 有区别吗？

+ + x 称为前增量，而 x + + 称为后增量。

int x = 5, y = 5;


System.out.println(++x); // outputs 6
System.out.println(x); // outputs 6


System.out.println(y++); // outputs 5
System.out.println(y); // outputs 6

是的,

int x=5;
System.out.println(++x);

将打印 6和

int x=5;
System.out.println(x++);

将打印 5。

是的

+ + x 递增 x 的值，然后返回 x
X + + 返回 x 的值，然后递增

例如:

x=0;
a=++x;
b=x++;

在代码运行之后，a 和 b 都是1，但 x 是2。

是的，在表达式中使用 + + X，X + 1。使用 X + + ，X 将在表达式中使用，并且 X 只有在表达式计算完成后才会增加。

如果 X = 9，使用 + + X，则使用值10，否则使用值9。

如果它像许多其他语言一样，你可能想尝试一下:

i = 0;
if (0 == i++) // if true, increment happened after equality check
if (2 == ++i) // if true, increment happened before equality check

如果上述情况没有发生，它们可能是等价的

是的。

public class IncrementTest extends TestCase {


public void testPreIncrement() throws Exception {
int i = 0;
int j = i++;
assertEquals(0, j);
assertEquals(1, i);
}


public void testPostIncrement() throws Exception {
int i = 0;
int j = ++i;
assertEquals(1, j);
assertEquals(1, i);
}
}

是的，返回的值分别是递增之后和之前的值。

class Foo {
public static void main(String args[]) {
int x = 1;
int a = x++;
System.out.println("a is now " + a);
x = 1;
a = ++x;
System.out.println("a is now " + a);
}
}


$ java Foo
a is now 1
a is now 2

这些被称为后缀和前缀运算符。两者都将向变量添加1，但是语句的结果有所不同。

int x = 0;
int y = 0;
y = ++x;            // result: y=1, x=1


int x = 0;
int y = 0;
y = x++;            // result: y=0, x=1

我从它最近的一个 开始降落到这里，尽管这个问题已经得到了充分的回答，但我还是忍不住反编译了代码并添加了“又一个答案”: -)

准确地说(可能有点迂腐) ,

int y = 2;
y = y++;

汇编为:

int y = 2;
int tmp = y;
y = y+1;
y = tmp;

如果你是 javac这个 Y.java类:

public class Y {
public static void main(String []args) {
int y = 2;
y = y++;
}
}

和 javap -c Y，您将获得以下 jvm 代码(我已经允许在 Java 虚拟机规范的帮助下注释 main 方法) :

public class Y extends java.lang.Object{
public Y();
Code:
0:   aload_0
1:   invokespecial  #1; //Method java/lang/Object."<init>":()V
4:   return


public static void main(java.lang.String[]);
Code:
0:   iconst_2 // Push int constant `2` onto the operand stack.


1:   istore_1 // Pop the value on top of the operand stack (`2`) and set the
// value of the local variable at index `1` (`y`) to this value.


2:   iload_1  // Push the value (`2`) of the local variable at index `1` (`y`)
// onto the operand stack


3:   iinc  1, 1 // Sign-extend the constant value `1` to an int, and increment
// by this amount the local variable at index `1` (`y`)


6:   istore_1 // Pop the value on top of the operand stack (`2`) and set the
// value of the local variable at index `1` (`y`) to this value.
7:   return


}

因此，我们终于有了:

0,1: y=2
2: tmp=y
3: y=y+1
6: y=tmp

好的，我之所以来到这里，是因为我最近在检查经典堆栈实现时遇到了同样的问题。只是提醒一下，这是在基于数组的 Stack 实现中使用的，它比链表实现稍微快一点。

下面的代码，检查 push 和 pop func。

public class FixedCapacityStackOfStrings
{
private String[] s;
private int N=0;


public FixedCapacityStackOfStrings(int capacity)
{ s = new String[capacity];}


public boolean isEmpty()
{ return N == 0;}


public void push(String item)
{ s[N++] = item; }


public String pop()
{
String item = s[--N];
s[N] = null;
return item;
}
}

是的，有区别，在 x + + (后增量)的情况下，x 的值将在表达式中使用，并且在表达式被求值后 x 将增加1，另一方面，x + 1将在表达式中使用。 举个例子:

public static void main(String args[])
{
int i , j , k = 0;
j = k++; // Value of j is 0
i = ++j; // Value of i becomes 1
k = i++; // Value of k is 1
System.out.println(k);
}

这个问题已经得到了回答，但请允许我从我的角度补充一下。

首先，++表示递增1，--表示递减1。

现在，X + + 表示这一行之后的增量 X，而 + + x表示这一行之前的增量 X。

检查这个例子

class Example {
public static void main (String args[]) {
int x=17,a,b;
a=x++;
b=++x;
System.out.println(“x=” + x +“a=” +a);
System.out.println(“x=” + x + “b=” +b);
a = x--;
b = --x;
System.out.println(“x=” + x + “a=” +a);
System.out.println(“x=” + x + “b=” +b);
}
}

它将产生以下结果:

x=19 a=17
x=19 b=19
x=18 a=19
x=17 b=17

使用 i + + 时，它被称为后增量，该值在任何上下文中使用，然后增量; + + i 是前增量先增量该值，然后在上下文中使用它。

如果您没有在任何上下文中使用它，那么使用什么并不重要，但是按照约定使用后增量。

考虑到电脑的实际功能。

+ + x: 从内存加载 x，递增，使用，存储回内存。

X + + : 从内存加载 x，使用，增量，存储回内存。

考虑一下: A = 0 X = f (a + +) Y = f (+ + a)

其中函数 f (p)返回 p + 1

X 将是1(或2)

Y 将是2(或1)

这就是问题所在。编译器的作者是在检索后、使用后还是存储后传递参数。

一般来说，就用 x = x + 1，这样简单多了。

两者有很大的区别。

正如大多数答案已经指出的理论，我想指出一个简单的例子:

int x = 1;
//would print 1 as first statement will x = x and then x will increase
int x = x++;
System.out.println(x);

现在让我们看看 ++x:

int x = 1;
//would print 2 as first statement will increment x and then x will be stored
int x = ++x;
System.out.println(x);

在 Java这是有区别的中，在 X + + 和 + + x之间

+ + x 是一个前缀形式: 它递增变量表达式，然后在表达式中使用新值。

例如，如果在代码中使用:

int x = 3;


int y = ++x;
//Using ++x in the above is a two step operation.
//The first operation is to increment x, so x = 1 + 3 = 4
//The second operation is y = x so y = 4


System.out.println(y); //It will print out '4'
System.out.println(x); //It will print out '4'

X + + 是后缀形式: 变量值首先在表达式中使用，然后在操作之后递增。

例如，如果在代码中使用:

int x = 3;


int y = x++;
//Using x++ in the above is a two step operation.
//The first operation is y = x so y = 3
//The second operation is to increment x, so x = 1 + 3 = 4


System.out.println(y); //It will print out '3'
System.out.println(x); //It will print out '4'

希望这是明确的。运行和播放以上代码应该有助于您的理解。

public static void main(String[] args) {


int a = 1;
int b = a++; // this means b = whatever value a has but, I want to
increment a by 1
    

System.out.println("a is --> " + a);    //2
System.out.println("b is --> " + b);    //1
a = 1;
b = ++a;  // this means b = a+1
    

System.out.println("now a is still  --> " + a);    //2
System.out.println("but b is --> " + b);           //2


}

试着这样想: 从左到右做你首先遇到的事情。如果你先看到 x，那么这个值将用于计算当前处理的表达式，如果你先看到增量(+ +) ，然后将其加到变量的当前值中，继续计算表达式。很简单