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

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

++ x è chiamato preincremento mentre x ++ è chiamato 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

sì

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

esempio:

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

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

Questi sono noti come operatori di suffisso e prefisso. Entrambi aggiungeranno 1 alla variabile ma c'è una differenza nel risultato dell'istruzione.

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

Sì,

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

stamperà 6e

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

stamperà 5.

Sono atterrato qui da uno dei suoi recenti duplicati , e sebbene questa domanda abbia più che una risposta, non ho potuto fare a meno di decompilare il codice e aggiungere "ancora un'altra risposta" :-)

Per essere precisi (e probabilmente un po 'pedanti),

int y = 2;
y = y++;

è compilato in:

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

Se javacquesta Y.javaclasse:

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

e javap -c Yottieni il seguente codice jvm (mi sono permesso di commentare il metodo principale con l'aiuto della specifica Java Virtual Machine ):

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

}

Quindi, finalmente abbiamo:

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

Quando si considera cosa fa effettivamente il computer ...

++ x: carica x dalla memoria, incrementa, usa, salva in memoria.

x ++: carica x dalla memoria, usa, incrementa, salva in memoria.

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

dove la funzione f (p) restituisce p + 1

x sarà 1 (o 2)

sarai 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.

In genere, usa x = x + 1. È molto più semplice.

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

++ x è una forma di prefisso: incrementa l'espressione delle variabili quindi utilizza il nuovo valore nell'espressione.

Ad esempio, se utilizzato nel 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 ++ è un formato suffisso: il valore della variabile viene prima utilizzato nell'espressione e poi viene incrementato dopo l'operazione.

Ad esempio, se utilizzato nel 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 la tua comprensione.

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

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

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

Se è come molte altre lingue potresti voler fare un semplice tentativo:

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

Se quanto sopra non accade in questo modo, potrebbero essere equivalenti

Sì, il valore restituito è rispettivamente il valore dopo e prima dell'incremento.

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, sono arrivato qui perché di recente ho riscontrato lo stesso problema durante il controllo dell'implementazione dello stack classico. Solo un promemoria che questo viene utilizzato nell'implementazione basata su array di Stack, che è un po 'più veloce di quella dell'elenco collegato.

Codice sotto, controlla le funzioni 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;
  }
}

Sì, c'è una differenza, in caso di x ++ (postincremento), il valore di x verrà utilizzato nell'espressione e x verrà incrementato di 1 dopo che l'espressione è stata valutata, d'altra parte ++ x (preincremento), x + 1 verrà utilizzato nell'espressione. Facciamo 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);  
}

La domanda ha già una risposta, ma consentitemi di aggiungere anche da parte mia.

Prima di tutto ++ significa incremento di uno e - significa decremento di uno.

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

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

Fornirà il seguente output:

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

Con i ++, si chiama postincremento e il valore viene utilizzato in qualsiasi contesto venga poi incrementato; ++ i è preincrement incrementa prima il valore e poi lo usa nel contesto.

Se non lo stai usando in nessun contesto, non importa cosa usi, ma il postincremento è usato per convenzione.

C'è un'enorme differenza.

Poiché la maggior parte delle risposte ha già evidenziato la teoria, vorrei segnalare un semplice esempio:

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

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