¿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

Sí,

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

imprimirá 6 y

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

imprimirá 5.

Answer 3

sí

++ x incrementa el valor de x y después vuelve x
x ++ devuelve el valor de x y luego incrementos de

ejemplo:

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

después se ejecuta el código ambos a y b serán 1 pero x será 2.

Answer 4

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.

Así que si X = 9, usando ++ X, se utilizará el valor 10, de lo contrario, el valor 9.

Answer 5

Si es como muchos otros idiomas es posible que desee tener una oportunidad sencilla:

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 sucede así, que pueden ser equivalentes

Answer 6

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 7

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

Se conocen como operadores de prefijo y prefijo. 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 9

aterricé aquí desde uno de sus últimos dup 's, y aunque esta pregunta es más que respondió, no pude evitar descompilación el código y añadir 'otra respuesta' :-)

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

int y = 2; 
y = y++; 

se compila en:

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

Si javac este Y.java clase:

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

y javap -c Y, se obtiene el siguiente código JVM (I ha permitido que comente el principal método con la ayuda de la 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 

} 

lo tanto , finalmente tenemos:

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

Answer 10

OK, llegué aquí porque recientemente me encontré con el mismo problema cuando verificando 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.

A continuación, compruebe la función 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 11

Sí, hay una diferencia, en caso de x ++ (postincremento), el valor de x será utilizada en la expresión y x se incrementa en 1 después de la expresión se ha evaluado, por otro lado ++ x (preincremento), x + 1 se usará en la expresión. Tomemos 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 12

La pregunta ya está contestada, pero permítanme añadir por mi parte también.

En primer lugar ++ significa la subasta por uno y - significa decremento por uno.

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

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

Se dará a la siguiente salida:

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

Answer 13

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

Si no lo está utilizando en ningún contexto, no importa cuál sea su uso, pero la convención utiliza postincrement.

Answer 14

Al considerar lo que realmente hace la computadora ...

++ x: x la carga de la memoria, de la subasta, el uso, almacenar de nuevo a 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í está 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 15

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 sencillo:

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 vamos a 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); 

Answer 16

En Java hay 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 utiliza 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 postfix: El valor de variables se utiliza por primera vez en la expresión y luego se incrementa después de la operación.

Por ejemplo si se utiliza 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' 

la esperanza que esto está claro. Correr y jugar con el código anterior debería ayudarlo a comprender.