Is er een verschil tussen x++ en ++x in java?

Is er een verschil tussen ++x en x++ in Java?

Antwoord 1, autoriteit 100%

++x wordt preincrement genoemd terwijl x++ postincrement wordt genoemd.

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

Antwoord 2, autoriteit 22%

ja

++x verhoogt de waarde van x en retourneert vervolgens x
x++ retourneert de waarde van x en wordt vervolgens verhoogd

voorbeeld:

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

nadat de code is uitgevoerd, zijn zowel a als b 1 maar x is 2.

Antwoord 3, autoriteit 6%

Deze staan bekend als postfix- en prefix-operators. Beide zullen 1 toevoegen aan de variabele, maar er is een verschil in het resultaat van de instructie.

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

Antwoord 4, autoriteit 4%

Ja,

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

drukt 6en

. af

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

drukt 5af.

Antwoord 5, autoriteit 3%

Ik ben hier beland via een van de recente dup‘s, en hoewel deze vraag meer dan beantwoord is, kon ik het niet laten de code te decompileren en “nog een antwoord” toe te voegen 🙂

Om precies te zijn (en waarschijnlijk een beetje pedant),

int y = 2;
y = y++;

is gecompileerd in:

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

Als je javacdeze Y.javaklas:

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

en javap -c Y, krijg je de volgende jvm-code (ik heb me toestemming gegeven om de hoofdmethode te becommentariëren met behulp van de Java Virtual Machine Specificatie):

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
}

We hebben dus eindelijk:

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

Antwoord 6, autoriteit 3%

Als je bedenkt wat de computer eigenlijk doet…

++x: laad x uit het geheugen, verhoog, gebruik, sla terug in het geheugen op.

x++: laad x uit het geheugen, gebruik, verhoog, sla terug in het geheugen op.

Overweeg:
een = 0
x = f(a++)
y = f(++a)

waarbij functie f(p) p + 1 teruggeeft

x wordt 1 (of 2)

j wordt 2 (of 1)

En daar zit het probleem. Heeft de auteur van de compiler de parameter doorgegeven na het ophalen, na gebruik of na opslag.

Gebruik in het algemeen gewoon x = x + 1. Het is veel eenvoudiger.

Antwoord 7, autoriteit 3%

In Java is er een verschiltussen x++ en ++x

++x is een voorvoegselvorm:
Het verhoogt de expressie van de variabelen en gebruikt vervolgens de nieuwe waarde in de expressie.

Bijvoorbeeld indien gebruikt in code:

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++ is een postfix-vorm:
De waarde van de variabelen wordt eerst gebruikt in de uitdrukking en wordt daarna verhoogd na de bewerking.

Bijvoorbeeld indien gebruikt in code:

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' 

Ik hoop dat dit duidelijk is. Rennen en spelen met de bovenstaande code zou je begrip moeten helpen.

Antwoord 8

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

Antwoord 9

Ja, bij gebruik van ++X wordt X+1 gebruikt in de uitdrukking. Als u X++ gebruikt, wordt X gebruikt in de uitdrukking en wordt X alleen verhoogd nadat de uitdrukking is geëvalueerd.

Dus als X = 9, met ++X, wordt de waarde 10 gebruikt, anders de waarde 9.

Antwoord 10

Als het net als veel andere talen is, wil je het misschien eens proberen:

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

Als het bovenstaande niet zo gebeurt, kunnen ze gelijkwaardig zijn

Antwoord 11

Ja, de geretourneerde waarde is respectievelijk de waarde na en vóór de verhoging.

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

Antwoord 12

Ok, ik ben hier beland omdat ik onlangs hetzelfde probleem tegenkwam bij het controleren van de klassieke stack-implementatie. Gewoon een herinnering dat dit wordt gebruikt in de array-gebaseerde implementatie van Stack, die een beetje sneller is dan de gekoppelde lijst.

Code hieronder, controleer de push- en pop-functie.

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

Antwoord 13

Ja, er is een verschil, in het geval van x++(postincrement), wordt de waarde van x gebruikt in de uitdrukking en wordt x verhoogd met 1 nadat de uitdrukking is geëvalueerd, aan de andere kant ++x(preincrement) , x+1 wordt gebruikt in de uitdrukking.
Neem een voorbeeld:

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

Antwoord 14

De vraag is al beantwoord, maar sta mij toe er ook van mijn kant aan toe te voegen.

Allereerst betekent ++een verhoging met één en —betekent een verhoging met één.

Nu betekent x++Toename xna deze regel en ++xbetekent Toename xvóór deze regel.

Controleer dit voorbeeld

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

Het geeft de volgende output:

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

Antwoord 15

Bij i++ wordt het postincrement genoemd, en de waarde wordt gebruikt in elke context die vervolgens wordt verhoogd; ++i is preincrement verhoogt de waarde eerst en gebruikt deze vervolgens in context.

Als je het in geen enkele context gebruikt, maakt het niet uit wat je gebruikt, maar postincrement wordt volgens afspraak gebruikt.

Antwoord 16

Er is een enorm verschil.

Omdat de meeste antwoorden al op de theorie hebben gewezen, wil ik een eenvoudig voorbeeld noemen:

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

Laten we eens kijken naar ++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);