java - postincremento - que es incremento en programacion

¿Hay alguna diferencia entre x++ y++ x en java?

Question

¿Hay alguna diferencia entre ++ x y x ++ en java?

Answer 1

++ x se llama preincremento, mientras que x ++ se llama postincremento.

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

Al considerar lo que la computadora realmente hace ...

++ x: cargar x de la memoria, incrementar, usar, almacenar de nuevo en la memoria.

x ++: cargue x de la memoria, use, incremente, almacene de nuevo en la memoria.

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

donde la función f (p) devuelve p + 1

x será 1 (o 2)

y será 2 (o 1)

Y ahí radica el problema. El autor del compilador pasó el parámetro después de la recuperación, después del uso o después del almacenamiento.

En general, simplemente use x = x + 1. Es mucho más simple.

Answer 3

Aterricé aquí desde uno de sus dup recientes, y aunque esta pregunta está más que respondida, no pude evitar descompilar el código y agregar "aún otra respuesta" :-)

Para ser preciso (y probablemente, un poco pedante),

int y = 2;
y = y++;

está compilado en:

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

Si javac esta clase Y.java :

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

y javap -c Y , obtienes el siguiente código jvm (me permití comentar el método principal con la ayuda de la especificación de máquina virtual Java ):

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

}

Por lo tanto, finalmente tenemos:

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

Answer 4

Con i ++, se llama postincremento, y el valor se usa en cualquier contexto y luego se incrementa; ++ i es preincremento incrementa el valor primero y luego lo usa en contexto.

Si no lo está usando en ningún contexto, no importa lo que use, pero la convención utiliza el postincrement.

Answer 5

En Java existe una diferencia entre x ++ y ++ x

++ x es una forma de prefijo: incrementa la expresión de variables y luego usa el nuevo valor en la expresión.

Por ejemplo, si se usa en 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 ++ es una forma de postfijo: el valor de las variables se utiliza por primera vez en la expresión y luego se incrementa después de la operación.

Por ejemplo, si se usa en 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 esto esté claro. Correr y jugar con el código anterior debería ayudarlo a comprender.

Answer 6

Estos se conocen como operadores de prefijo y posfijo. Ambos agregarán 1 a la variable pero hay una diferencia en el resultado de la declaración.

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 7

Hay una gran diferencia

Como la mayoría de las respuestas ya han señalado la teoría, me gustaría señalar un ejemplo 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);

Ahora veamos ++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);

Answer 8

La pregunta ya está respondida, pero permítanme agregar de mi lado también.

Primero de todo ++ significa incremento en uno y significa disminución en uno.

Ahora x ++ significa Incremento x después de esta línea y ++ x significa Incremento x antes de esta línea.

Verifique este ejemplo

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

Dará el siguiente resultado:

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

Answer 9

OK, llegué aquí porque recientemente encontré el mismo problema cuando comprobaba la implementación clásica de la pila. Solo un recordatorio de que esto se usa en la implementación basada en matriz de Stack, que es un poco más rápida que la lista enlazada.

Codifique a continuación, revise los botones push y 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;
  }
}

Answer 10

Sí,

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

imprimirá 6 y

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

se imprimirá 5 .

Answer 11

Sí, el valor devuelto es el valor después y antes del 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

Sí, hay una diferencia, en caso de x ++ (postincremento), el valor de x se usará en la expresión y x se incrementará en 1 después de que se haya evaluado la expresión, por otro lado ++ x (preincremento), x + 1 se usará en la expresión. Tome un ejemplo:

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 13

Sí, usando ++ X, X + 1 se usará en la expresión. Usando X ++, X se usará en la expresión y X solo se incrementará después de que se haya evaluado la expresión.

Entonces, si X = 9, usando ++ X, se usará el valor 10, de lo contrario, el valor 9.

Answer 14

Sí.

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 15

Si es como muchos otros idiomas, es posible que desee intentarlo de manera simple:

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

Si lo anterior no ocurre así, pueden ser equivalentes

Answer 16

sí

++ x incrementa el valor de x y luego devuelve x
x ++ devuelve el valor de x y luego aumenta

ejemplo:

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

después de ejecutar el código, tanto a como b serán 1, pero x será 2.