Java'da x ++ ve ++ x arasında bir fark var mı?

Java'da ++ x ve x ++ arasında bir fark var mı?

++ x, ön artış olarak adlandırılırken, x ++ ise artımlı olarak adlandırılır.

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

Evet

++ x, x'in değerini artırır ve ardından x
x ++, x'in değerini ve ardından artışları döndürür

misal:

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

kod çalıştırıldıktan sonra hem a hem de b 1 olacak ancak x 2 olacaktır.

Bunlar, sonek ve önek operatörleri olarak bilinir. Her ikisi de değişkene 1 ekler ancak ifadenin sonucunda bir fark vardır.

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

Evet,

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

yazdıracak 6ve

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

yazdıracak 5.

Buraya yakın zamandaki kopyalarından birinden indim ve bu soru yanıtlanandan daha fazla olsa da, kodu çözmekten ve "yine başka bir yanıt" eklemekten kendimi alamadım :-)

Doğru olmak (ve muhtemelen biraz bilgiçlik taslamak),

int y = 2;
y = y++;

şu şekilde derlenir:

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

Eğer javacbu Y.javasınıfsanız:

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

ve javap -c Yaşağıdaki jvm kodunu alırsınız ( Java Sanal Makine Spesifikasyonu yardımıyla ana yöntemi yorumlamama izin verdim ):

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

}

Böylece nihayet elimizde:

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

Bilgisayarın gerçekte ne yaptığını düşünürken ...

++ x: x'i bellekten yükle, artır, kullan, belleğe geri yükle.

x ++: x'i bellekten yükle, kullan, artır, belleğe geri yükle.

Şunu düşünün: a = 0 x = f (a ++) y = f (++ a)

f (p) işlevi p + 1'i döndürür

x 1 (veya 2) olacaktır

y 2 (veya 1) olacaktır

Ve problem burada yatıyor. Derleyicinin yazarı parametreyi aldıktan sonra, kullanımdan sonra veya depolamadan sonra geçti mi?

Genel olarak, x = x + 1 kullanın. Çok daha basit.

Java'da x ++ ve ++ x arasında bir fark vardır

++ x bir önek biçimidir: Değişken ifadesini artırır ve ardından ifadede yeni değeri kullanır.

Örneğin kodda kullanılıyorsa:

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 ++ bir sonek formudur: Değişken değeri önce ifadede kullanılır ve ardından işlemden sonra artırılır.

Örneğin kodda kullanılıyorsa:

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' 

Umarım bu açıktır. Yukarıdaki kodla koşmak ve oynamak, anlamanıza yardımcı olacaktır.

Evet.

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

Evet, ++ X kullanıldığında, ifadede X + 1 kullanılacaktır. X ++ kullanıldığında, ifadede X kullanılacak ve X yalnızca ifade değerlendirildikten sonra artırılacaktır.

Yani, X = 9 ise, ++ X kullanılıyorsa, 10 değeri, aksi takdirde 9 değeri kullanılacaktır.

Diğer birçok dil gibiyse, basit bir denemek isteyebilirsiniz:

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

Yukarıdakiler böyle olmazsa, eşdeğer olabilirler

Evet, döndürülen değer sırasıyla artıştan sonraki ve önceki değerdir.

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

Tamam, buraya geldim çünkü son zamanlarda klasik yığın uygulamasını kontrol ederken aynı sorunla karşılaştım. Bunun bağlantılı liste olandan biraz daha hızlı olan dizi tabanlı Stack uygulamasında kullanıldığını hatırlatmak isteriz.

Aşağıdaki kod, push ve pop işlevini kontrol edin.

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

Evet, bir fark var, x ++ (sonradan artırma) durumunda, ifadede x değeri kullanılacak ve ifade değerlendirildikten sonra x 1 artırılacak, diğer yandan ++ x (ön artırma), x + İfadede 1 kullanılacaktır. Bir örnek alın:

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

Soru zaten cevaplandı, ancak kendi tarafımdan da eklememe izin verin.

Her şeyden önce ++ , bir artış anlamına gelir ve - bir artış anlamına gelir.

Şimdi x ++ araçları Artış x bu satırdan sonra ve ++ x vasıta Artış x bu satırdan önce.

Bu Örneği Kontrol Edin

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

Aşağıdaki çıktıyı verecektir:

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

İ ++ ile buna sonradan artırma denir ve değer, daha sonra artırılan bağlamda kullanılır; ++ i, ön artırmadır, önce değeri artırır ve ardından bunu bağlamda kullanır.

Herhangi bir bağlamda kullanmıyorsanız, ne kullandığınız önemli değildir, ancak sonradan artırma geleneksel olarak kullanılır.

Çok büyük bir fark var.

Cevapların çoğu zaten teoriye işaret ettiğinden, basit bir örneğe işaret etmek istiyorum:

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

Şimdi bakalım ++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);