Gibt es einen Unterschied zwischen x ++ und ++ x in Java?

Gibt es einen Unterschied zwischen ++ x und x ++ in Java?

++ x heißt Vorinkrement, während x ++ Nachinkrement heißt.

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

Ja

++ x erhöht den Wert von x und gibt dann x zurück.
x ++ gibt den Wert von x zurück und erhöht dann

Beispiel:

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

Nachdem der Code ausgeführt wurde, sind sowohl a als auch b 1, aber x ist 2.

Diese werden als Postfix- und Präfixoperatoren bezeichnet. Beide addieren 1 zur Variablen, aber es gibt einen Unterschied im Ergebnis der Anweisung.

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

Ja,

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

druckt 6und

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

wird gedruckt 5.

Ich bin hier von einem der letzten Dups gelandet , und obwohl diese Frage mehr als beantwortet ist, konnte ich nicht anders, als den Code zu dekompilieren und "noch eine andere Antwort" hinzuzufügen :-)

Um genau zu sein (und wahrscheinlich ein bisschen pedantisch),

int y = 2;
y = y++;

wird zusammengestellt in:

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

Wenn Sie javacdiese Y.javaKlasse:

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

und javap -c YSie erhalten den folgenden JVM-Code (ich habe mir erlaubt, die Hauptmethode mithilfe der Java Virtual Machine-Spezifikation zu kommentieren ):

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

}

Somit haben wir endlich:

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

Wenn man bedenkt, was der Computer tatsächlich tut ...

++ x: x aus dem Speicher laden, inkrementieren, verwenden, zurück in den Speicher speichern.

x ++: lade x aus dem Speicher, benutze, inkrementiere, speichere zurück in den Speicher.

Betrachten Sie: a = 0 x = f (a ++) y = f (++ a)

wobei die Funktion f (p) p + 1 zurückgibt

x ist 1 (oder 2)

y wird 2 (oder 1) sein

Und darin liegt das Problem. Hat der Autor des Compilers den Parameter nach dem Abrufen, nach der Verwendung oder nach dem Speichern übergeben?

Verwenden Sie im Allgemeinen einfach x = x + 1. Es ist viel einfacher.

In Java gibt es einen Unterschied zwischen x ++ und ++ x

++ x ist eine Präfixform: Sie erhöht den Variablenausdruck und verwendet dann den neuen Wert im Ausdruck.

Zum Beispiel, wenn im Code verwendet:

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 ++ ist eine Postfix-Form: Der Variablenwert wird zuerst im Ausdruck verwendet und dann nach der Operation inkrementiert.

Zum Beispiel, wenn im Code verwendet:

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' 

Hoffe das ist klar. Das Ausführen und Spielen mit dem obigen Code sollte Ihr Verständnis verbessern.

Ja.

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

Ja, bei Verwendung von ++ X wird X + 1 im Ausdruck verwendet. Bei Verwendung von X ++ wird X im Ausdruck verwendet und X wird erst erhöht, nachdem der Ausdruck ausgewertet wurde.

Wenn also X = 9 ist und ++ X verwendet, wird der Wert 10 verwendet, andernfalls der Wert 9.

Wenn es wie viele andere Sprachen ist, möchten Sie vielleicht einen einfachen Versuch machen:

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

Wenn das oben genannte nicht so passiert, können sie gleichwertig sein

Ja, der zurückgegebene Wert ist der Wert nach bzw. vor der Inkrementierung.

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, ich bin hier gelandet, weil ich kürzlich beim Überprüfen der klassischen Stack-Implementierung auf dasselbe Problem gestoßen bin. Nur eine Erinnerung daran, dass dies in der Array-basierten Implementierung von Stack verwendet wird, die etwas schneller ist als die mit verknüpften Listen.

Code unten, überprüfen Sie die Push- und Pop-Funktion.

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

Ja, es gibt einen Unterschied, falls x ++ (Nachinkrementierung), der Wert von x im Ausdruck verwendet wird und x nach Auswertung des Ausdrucks um 1 erhöht wird, andererseits ++ x (Vorinkrementierung), x + 1 wird im Ausdruck verwendet. Nehmen Sie ein Beispiel:

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

Die Frage ist bereits beantwortet, aber ich kann sie auch von meiner Seite hinzufügen.

Zuallererst bedeutet ++ Inkrementieren um eins und - Dekrementieren um eins.

Jetzt bedeutet x ++ Inkrement x nach dieser Zeile und ++ x bedeutet Inkrement x vor dieser Zeile.

Überprüfen Sie dieses Beispiel

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

Es wird die folgende Ausgabe geben:

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

In i ++ heißt es Nachinkrementierung, und der Wert wird in jedem Kontext verwendet, der dann inkrementiert wird. ++ i Inkrementieren erhöht zuerst den Wert und verwendet ihn dann im Kontext.

Wenn Sie es in keinem Kontext verwenden, spielt es keine Rolle, was Sie verwenden, aber die Nachinkrementierung wird gemäß Konvention verwendet.

Es gibt einen großen Unterschied.

Da die meisten Antworten bereits auf die Theorie hingewiesen haben, möchte ich ein einfaches Beispiel nennen:

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

Nun wollen wir sehen ++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);