Existe uma diferença entre x ++ e ++ x em java?

Existe uma diferença entre ++ x e x ++ em java?

   

++ x é chamado de pré-incremento enquanto x ++ é chamado de pós-incremento.

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 

sim

++ x aumenta o valor de x e retorna x
x ++ retorna o valor de x e, em seguida, incrementa

exemplo:

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

depois que o código for executado, tanto a como b serão 1, mas x será 2.

Estes são conhecidos como operadores de postfix e prefixo. Ambos adicionarão 1 à variável, mas há uma diferença no resultado da declaração.

 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 

Sim,

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

imprimirá 6 e

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

vai imprimir 5 .

Eu cheguei aqui de um de seus recentes dup ‘s, e embora essa pergunta seja mais do que respondida, eu não pude deixar de descompilar o código e adicionar “mais uma resposta” 🙂

Para ser preciso (e provavelmente um pouco pedante),

 int y = 2; y = y++; 

é compilado em:

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

Se você javac esta class Y.java :

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

e javap -c Y , você obtém o seguinte código jvm (permiti-me comentar o método principal com a ajuda da Java Virtual Machine Specification ):

 public class Y extends java.lang.Object{ public Y(); Code: 0: aload_0 1: invokespecial #1; //Method java/lang/Object."":()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 } 

Assim, finalmente temos:

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

Ao considerar o que o computador realmente faz …

++ x: carrega x da memory, incrementa, usa, armazena de volta na memory.

x ++: carrega x da memory, usa, incrementa, armazena de volta na memory.

Considere: a = 0 x = f (a ++) y = f (++ a)

onde a function f (p) retorna p + 1

x será 1 (ou 2)

y será 2 (ou 1)

E aí está o problema. O autor do compilador passou o parâmetro após a recuperação, após o uso ou após o armazenamento.

Geralmente, apenas use x = x + 1. É mais simples.

Sim.

 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); } } 

Em Java há uma diferença entre x ++ e ++ x

++ x é um formulário de prefixo: Ele incrementa a expressão de variables ​​e usa o novo valor na expressão.

Por exemplo, se usado no código:

 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 ++ é um formulário de postfix: O valor de variables ​​é usado pela primeira vez na expressão e, em seguida, é incrementado após a operação.

Por exemplo, se usado no código:

 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' 

Espero que isso esteja claro. Correr e brincar com o código acima deve ajudar sua compreensão.

Sim, usando ++ X, X + 1 será usado na expressão. Usando X ++, X será usado na expressão e X só será aumentado após a expressão ter sido avaliada.

Então, se X = 9, usando ++ X, o valor 10 será usado, senão, o valor 9.

Se é como muitos outros idiomas, você pode querer uma simples tentativa:

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

Se o acima não acontecer assim, eles podem ser equivalentes

Sim, o valor retornado é o valor após e antes da incremento, respectivamente.

 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 

Ok, eu cheguei aqui porque recentemente me deparei com o mesmo problema ao verificar a implementação clássica da pilha. Apenas um lembrete de que isso é usado na implementação baseada em matriz do Stack, que é um pouco mais rápida do que a linked list.

Código abaixo, verifique o push e 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; } } 

Sim, há uma diferença, no caso de x ++ (pós-incremento), valor de x será usado na expressão e x será incrementado em 1 após a expressão ter sido avaliada, por outro lado ++ x (pré-incremento), x + 1 será usado na expressão. Tomemos um exemplo:

 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); } 

A questão já está respondida, mas permita-me adicionar do meu lado também.

Primeiramente, significa incrementar em um e significa decrementar em um.

Agora, x ++ significa Incremento x após esta linha e ++ x significa Incremento x antes desta linha.

Verifique este exemplo

 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); } } 

Isso dará a seguinte saída:

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

Com o i ++, ele é chamado de pósincremento, e o valor é usado em qualquer contexto, em seguida, incrementado; ++ i é pré-incremento incrementa o valor primeiro e depois usa-o no contexto.

Se você não estiver usando em qualquer contexto, não importa o que você usa, mas o pós-incremento é usado por convenção.

Há uma enorme diferença.

Como a maioria das respostas já apontou a teoria, gostaria de destacar um exemplo fácil:

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

Agora vamos ver ++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);