Existe uma diferença entre ++ x e x ++ em java?
Existe uma diferença entre ++ x e x ++ em java?
Respostas:
++ 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 incrementa o valor de xe então retorna x
x ++ retorna o valor de xe então incrementa
exemplo:
x=0;
a=++x;
b=x++;
depois que o código for executado, aeb serão 1, mas x será 2.
Eles são conhecidos como operadores postfix e prefix. Ambos irão adicionar 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
suffix
?
Sim,
int x=5;
System.out.println(++x);
irá imprimir 6
e
int x=5;
System.out.println(x++);
irá imprimir 5
.
Eu cheguei aqui a partir de um de seus recentes dup 's e, embora esta pergunta esteja mais do que respondida, 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 Y.java
classe:
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 que eu comentasse 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."<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
}
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 memória, incrementa, usa, armazena de volta na memória.
x ++: carrega x da memória, usa, incrementa, armazena de volta na memória.
Considere: a = 0 x = f (a ++) y = f (++ a)
onde a função 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, basta usar x = x + 1. É muito mais simples.
Em Java, há uma diferença entre x ++ e ++ x
++ x é uma forma de prefixo: ele incrementa a expressão das variáveis e então 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 ++ é uma forma pós-fixada: o valor das variáveis é usado primeiro 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. Executar e brincar com o código acima deve ajudar na sua compreensão.
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);
}
}
Sim, o valor retornado é o valor após e antes da incrementação, 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, 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 array de Stack, que é um pouco mais rápida do que a de lista vinculada.
Código abaixo, verifique a função push e pop.
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á diferença, no caso de x ++ (pós-incremento), o valor de x será utilizado na expressão ex 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. Veja 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 pergunta já foi respondida, mas permita-me acrescentar da minha parte também.
Em primeiro lugar, ++ significa incremento de um e - significa decremento de 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);
}
}
Ele dará a seguinte saída:
x=19 a=17
x=19 b=19
x=18 a=19
x=17 b=17
Com i ++, é chamado de pós-incremento, e o valor é usado em qualquer contexto e então incrementado; ++ i is preincrement incrementa o valor primeiro e depois o usa no contexto.
Se você não estiver usando em nenhum contexto, não importa o que você use, 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 apontar 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);