Apakah ada perbedaan antara x ++ dan ++ x di java?

Apakah ada perbedaan antara ++ x dan x ++ di java?

++ x disebut preincrement sedangkan x ++ disebut postincrement.

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

Iya

++ x menambah nilai x dan kemudian mengembalikan x
x ++ mengembalikan nilai x dan kemudian menambah

contoh:

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

setelah kode dijalankan baik a dan b akan menjadi 1 tetapi x akan menjadi 2.

Ini dikenal sebagai operator postfix dan prefix. Keduanya akan menambahkan 1 ke variabel tetapi ada perbedaan pada hasil pernyataannya.

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

Iya,

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

akan mencetak 6dan

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

akan mencetak 5.

Saya mendarat di sini dari salah satu dup -nya baru-baru ini , dan meskipun pertanyaan ini lebih dari yang dijawab, saya tidak dapat membantu menguraikan kode dan menambahkan "jawaban lain" :-)

Untuk akuratnya (dan mungkin, agak terlalu sombong),

int y = 2;
y = y++;

dikompilasi menjadi:

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

Jika Anda kelas javacini Y.java:

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

dan javap -c Y, Anda mendapatkan kode jvm berikut (saya mengizinkan saya untuk mengomentari metode utama dengan bantuan Spesifikasi Mesin Virtual Java ):

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

}

Jadi, akhirnya kami memiliki:

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

Saat mempertimbangkan apa yang sebenarnya dilakukan komputer ...

++ x: memuat x dari memori, kenaikan, penggunaan, simpan kembali ke memori.

x ++: memuat x dari memori, menggunakan, menambah, menyimpan kembali ke memori.

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

di mana fungsi f (p) mengembalikan p + 1

x akan menjadi 1 (atau 2)

y akan menjadi 2 (atau 1)

Dan di situlah letak masalahnya. Apakah pembuat kompilator meneruskan parameter setelah pengambilan, setelah digunakan, atau setelah penyimpanan.

Umumnya, gunakan saja x = x + 1. Ini jauh lebih sederhana.

Di Java ada perbedaan antara x ++ dan ++ x

++ x adalah bentuk awalan: Ini menambah ekspresi variabel kemudian menggunakan nilai baru dalam ekspresi.

Misalnya jika digunakan dalam kode:

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 ++ adalah bentuk postfix: Nilai variabel pertama kali digunakan dalam ekspresi dan kemudian bertambah setelah operasi.

Misalnya jika digunakan dalam kode:

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' 

Semoga ini jelas. Menjalankan dan bermain dengan kode di atas akan membantu pemahaman Anda.

Iya.

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

Ya, menggunakan ++ X, X + 1 akan digunakan dalam ekspresi. Menggunakan X ++, X akan digunakan dalam ekspresi dan X hanya akan dinaikkan setelah ekspresi dievaluasi.

Jadi jika X = 9, menggunakan ++ X, nilai 10 akan digunakan, jika tidak, nilai 9.

Jika ini seperti banyak bahasa lain, Anda mungkin ingin mencobanya:

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

Jika hal di atas tidak terjadi seperti itu, mungkin saja setara

Ya, nilai yang dikembalikan masing-masing adalah nilai setelah dan sebelum penambahan.

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

Oke, saya mendarat di sini karena baru-baru ini saya menemukan masalah yang sama saat memeriksa implementasi tumpukan klasik. Sekadar pengingat bahwa ini digunakan dalam implementasi Stack berbasis array, yang sedikit lebih cepat daripada yang tertaut-daftar.

Kode di bawah ini, periksa fungsi push dan 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;
  }
}

Ya, ada perbedaan, incase of x ++ (postincrement), nilai x akan digunakan dalam ekspresi dan x akan bertambah 1 setelah ekspresi dievaluasi, sebaliknya ++ x (preincrement), x + 1 akan digunakan dalam ekspresi. Ambil contoh:

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

Pertanyaannya sudah terjawab, tapi izinkan saya menambahkan dari sisi saya juga.

Pertama-tama ++ berarti kenaikan satu dan - berarti penurunan satu.

Sekarang x ++ berarti Increment x setelah baris ini dan ++ x berarti Increment x sebelum baris ini.

Periksa Contoh ini

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

Ini akan memberikan hasil sebagai berikut:

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

Dengan i ++, ini disebut postincrement, dan nilainya digunakan dalam konteks apa pun yang kemudian di-increment; ++ i adalah preincrement yang menambah nilai terlebih dahulu dan kemudian menggunakannya dalam konteks.

Jika Anda tidak menggunakannya dalam konteks apa pun, tidak masalah apa yang Anda gunakan, tetapi postincrement digunakan sesuai ketentuan.

Terdapat sebuah perbedaan yang besar.

Karena sebagian besar jawaban telah menunjukkan teorinya, saya ingin menunjukkan contoh yang mudah:

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

Sekarang mari kita lihat ++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);