C'è una differenza tra x ++ e ++ x in java?

Question

C'è una differenza tra ++ xe x ++ in java?

Answer 1

++ x è chiamato preincremento mentre x ++ si chiama 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); 

stamperà 6 e

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

stamperà 5.

Answer 3

sì

++ x incrementa il valore di x e poi restituisce x
x ++ restituisce il valore di x e quindi incrementa

esempio:

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

dopo che il codice viene eseguito sia a che b saranno 1 ma x sarà 2.

Answer 4

Sì, utilizzando ++ X, X + 1 verrà utilizzato nell'espressione. Usando X ++, X sarà usato nell'espressione e X sarà aumentato solo dopo che l'espressione è stata valutata.

Quindi, se X = 9, utilizzando ++ X, verrà utilizzato il valore di 10, altrimenti, il valore di 9.

Answer 5

Se è come molte altre lingue che si può decidere di avere una semplice prova:

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

Se ciò non accade, potrebbero essere equivalenti

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ì, il valore restituito è il valore dopo e prima dell'incremento, rispettivamente.

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

Questi sono noti come operatori postfisso e prefisso. Entrambi aggiungeranno 1 alla variabile ma c'è una differenza nel risultato della dichiarazione.

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

ho atterrato qui da uno dei suoi recenti dup 's, e anche se questa domanda è più che ha risposto, non ho potuto fare decompilazione del codice e aggiungendo 'l'ennesima risposta' :-)

per essere precisi (e probabilmente, un po 'saccente),

int y = 2; 
y = y++; 

è compilato in:

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

Se javac questo Y.java classe:

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

e javap -c Y, si ottiene il seguente codice JVM (I mi hanno permesso di commentare il metodo principale con l'aiuto del 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 

} 

Così , finalmente abbiamo:

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

Answer 10

OK, sono atterrato qui perché di recente ho riscontrato lo stesso problema quando controllando l'implementazione dello stack classico. Solo un promemoria che questo è usato nell'implementazione basata su array di Stack, che è un po 'più veloce di quella con lista collegata.

Codice sotto, selezionare la funzione 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; 
    } 
} 

Answer 11

Sì, c'è una differenza, in caso di x ++ (post-incremento), il valore di x sarà utilizzato nell'espressione e x sarà incrementato di 1 dopo l'espressione è stata valutata, invece ++ x (preincremento), x + 1 sarà usato nell'espressione. Prendiamo un esempio:

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 domanda è già una risposta, ma mi permetta di aggiungere da parte mia anche.

Prima di tutto ++ significa incremento per uno e - significa decrementa di uno.

Ora x ++ significa Incremento x dopo questa linea e ++ x significa Incremento x prima di questa linea.

controllare questo esempio

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à il seguente risultato:

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

Answer 13

Con i ++, si chiama post-incremento, e il valore viene utilizzato in qualsiasi contesto poi incrementato; ++ i è preincrement incrementa il valore per primo e poi lo usa nel contesto.

Se non lo si utilizza in qualsiasi contesto, non importa ciò che si utilizza, ma il postincremento viene utilizzato per convenzione.

Answer 14

Quando si considera ciò che realmente fa il computer ...

++ x: x carico dalla memoria, incremento, uso, conservare alla memoria.

x ++: caricare x dalla memoria, utilizzare, incrementare, archiviare in memoria.

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

cui funzione f (p) restituisce p + 1

x sarà 1 (o 2)

y sarà 2 (o 1)

e qui sta il problema. L'autore del compilatore ha passato il parametro dopo il recupero, dopo l'uso o dopo l'archiviazione.

Generalmente, basta usare x = x + 1. È molto più semplice.

Answer 15

C'è un'enorme differenza.

Come la maggior parte delle risposte hanno già sottolineato la teoria, vorrei sottolineare un esempio facile:

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

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

In Java c'è una differenza tra x ++ e ++ x

++ x è un modulo di prefisso: Aumenta l'espressione di variabili quindi utilizza il nuovo valore nell'espressione.

Per esempio, se usato in codice:

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 ++ è una forma suffisso: Il valore delle variabili viene dapprima utilizzato nell'espressione e poi viene incrementato dopo l'operazione.

Per esempio, se usato in codice:

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' 

Spero che questo sia chiaro. Correre e giocare con il codice sopra dovrebbe aiutare a capire.