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

Question

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

Answer 1

++ 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

Answer 2

Sim

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

exemplo:

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

após o código é executado tanto a como b será 1, mas x será 2.

Answer 3

Estes são conhecidos como operadores postfix e prefixo. Ambos irão adicionar 1 para a variável, mas há uma diferença no resultado da instruçã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

Answer 4

Sim,

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

imprimirá 6 e

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

imprimirá 5.

Answer 5

aterrei aqui de um de sua recente dup 's, e embora esta questão é mais do que respondeu, eu não poderia ajudar decompiling o código e adicionar 'mais uma resposta': -)

Para ser exato (e, provavelmente, um pedante bit),

int y = 2;
y = y++;

é compilado em:

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

Se você javac esta classe Y.java:

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

e javap -c Y, você começa o seguinte código JVM (Eu permiti-me a comentar o método principal com a ajuda do 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

Answer 6

Ao considerar que o computador realmente faz ...

++ x:. Carga x da memória, incremento, uso, armazenamento de volta para a memória

x ++:. Carga x de memória, uso de incremento, loja de volta à memória

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

em que a função f (p) retorna p + 1

x será de 1 (ou 2)

y será 2 (ou 1)

E é aí que reside o problema. O autor do compilador passar o parâmetro após a recuperação, após o uso, ou após o armazenamento.

Geralmente, basta usar x = x + 1. É a maneira mais simples.

Answer 7

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

++ x é uma forma de prefixo: Ele incrementa a expressão variáveis ??em seguida, utiliza 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 postfix: O valor variáveis ??é usado pela primeira vez na expressão e, em seguida, ele é 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' 

Hope isso é claro. Correndo e brincando com o código acima deve ajudar a sua compreensão.

Answer 8

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

Answer 9

Sim, usando ++ X, X + 1 será utilizada na expressão. Usando X ++ X vai ser utilizada na expressão e X só será aumentada, após a expressão foi avaliada.

Então, se X = 9, utilizando ++ X, o valor 10 será usado, caso contrário, o valor 9.

Answer 10

Se é como muitas outras línguas você pode querer ter uma tentativa simples:

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 acontece assim, eles podem ser equivalentes

Answer 11

Sim, o valor devolvido é o valor antes e após o 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

Answer 12

OK, eu aterrei aqui porque Recentemente, deparei com o mesmo problema ao verificar a implementação clássico pilha. Apenas um lembrete de que este é usado na implementação baseada em array de Stack, que é um pouco mais rápido do que a lista ligada um.

código abaixo, verifique a pressão 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;
  }
}

Answer 13

Sim, há uma diferença, de meter x ++ (pós-incremento), valor de x será usado na expressão e x será incrementado por 1 após a expressão foi avaliada, por outro lado ++ x (pré-incremento) , x + 1 vai ser utilizado 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);  
}

Answer 14

A pergunta já foi respondida, mas permitam-me acrescentar do meu lado também.

Antes de tudo ++ incremento meio por um e -. meio diminuir por um

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

Verifique neste 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 lhe dará o seguinte resultado:

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

Answer 15

Com i ++, é chamado de pós-incremento, eo valor é usado em qualquer contexto, em seguida, incrementado; ++ i é incrementos preIncrement o valor primeiro e depois usa-lo no contexto.

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

Answer 16

Há uma enorme diferença.

Como a maioria das respostas já apontaram 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);