Mengapa ini masuk ke loop tak terbatas?

Saya memiliki kode berikut:

public class Tests {
    public static void main(String[] args) throws Exception {
        int x = 0;
        while(x<3) {
            x = x++;
            System.out.println(x);
        }
    }
}

Kita tahu dia seharusnya menulis hanya x++atau x=x+1, tetapi pada x = x++itu pertama-tama harus dikaitkan xdengan dirinya sendiri, dan kemudian menambahkannya. Mengapa xterus 0sebagai nilai?

--memperbarui

Inilah bytecode:

public class Tests extends java.lang.Object{
public Tests();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[])   throws java.lang.Exception;
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   iconst_3
   4:   if_icmpge   22
   7:   iload_1
   8:   iinc    1, 1
   11:  istore_1
   12:  getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   15:  iload_1
   16:  invokevirtual   #3; //Method java/io/PrintStream.println:(I)V
   19:  goto    2
   22:  return

}

Saya akan membaca tentang petunjuk untuk mencoba memahami ...

Catatan : Awalnya saya memposting kode C # dalam jawaban ini untuk tujuan ilustrasi, karena C # memungkinkan Anda untuk melewati intparameter dengan referensi dengan refkata kunci. Saya telah memutuskan untuk memperbaruinya dengan kode Java legal yang sebenarnya menggunakan MutableIntkelas pertama yang saya temukan di Google untuk semacam perkiraan apa yang refada di C #. Saya benar-benar tidak tahu apakah itu membantu atau menyakiti jawabannya. Saya akan mengatakan bahwa saya secara pribadi belum melakukan semua pengembangan Java; jadi untuk semua yang saya tahu ada banyak cara idiomatis untuk menggambarkan hal ini.

Mungkin jika kita menulis metode untuk melakukan hal yang setara dengan apa x++yang akan membuatnya lebih jelas.

public MutableInt postIncrement(MutableInt x) {
    int valueBeforeIncrement = x.intValue();
    x.add(1);
    return new MutableInt(valueBeforeIncrement);
}

Baik? Tambahkan nilai yang diteruskan dan kembalikan nilai asli: itulah definisi dari operator peningkatan.

Sekarang, mari kita lihat bagaimana perilaku ini diputar dalam kode contoh Anda:

MutableInt x = new MutableInt();
x = postIncrement(x);

postIncrement(x)melakukan apa? Penambahan x, ya. Dan kemudian mengembalikan apa yang x ada sebelum kenaikan . Nilai pengembalian ini kemudian ditugaskan untuk x.

Jadi urutan nilai yang ditetapkan xadalah 0, lalu 1, lalu 0.

Ini mungkin masih lebih jelas jika kita menulis ulang di atas:

MutableInt x = new MutableInt();    // x is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
x = temp;                           // Now x is 0 again.

Fiksasi Anda pada fakta bahwa ketika Anda mengganti xdi sisi kiri dari tugas di atas dengan y, "Anda dapat melihat bahwa itu pertama kali menambah x, dan kemudian mengaitkannya dengan y" menurut saya bingung. Bukan xyang ditugaskan y; ini adalah nilai yang sebelumnya ditugaskanx . Sungguh, menyuntikkan ymembuat segalanya tidak berbeda dari skenario di atas; kami hanya punya:

MutableInt x = new MutableInt();    // x is 0.
MutableInt y = new MutableInt();    // y is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
y = temp;                           // y is still 0.

Jadi sudah jelas: x = x++secara efektif tidak mengubah nilai x. Itu selalu menyebabkan x memiliki nilai x ₀ , lalu x ₀ +1, dan kemudian x ₀ lagi.

Pembaruan : Secara kebetulan, jangan sampai Anda ragu xakan pernah mendapat 1 "antara" operasi kenaikan dan penugasan dalam contoh di atas, saya telah mengumpulkan demo singkat untuk menggambarkan bahwa nilai perantara ini memang "ada," meskipun akan tidak pernah "terlihat" di utas pelaksana.

Demo memanggil x = x++;secara berulang sementara utas terpisah terus mencetak nilai xke konsol.

public class Main {
    public static volatile int x = 0;

    public static void main(String[] args) {
        LoopingThread t = new LoopingThread();
        System.out.println("Starting background thread...");
        t.start();

        while (true) {
            x = x++;
        }
    }
}

class LoopingThread extends Thread {
    public @Override void run() {
        while (true) {
            System.out.println(Main.x);
        }
    }
}

Di bawah ini adalah kutipan dari output program di atas. Perhatikan kejadian 1s dan 0s yang tidak beraturan.

Mulai utas latar ...
0
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1

x = x++ bekerja dengan cara berikut:

• Pertama mengevaluasi ekspresi x++. Evaluasi ekspresi ini menghasilkan nilai ekspresi (yang merupakan nilai xsebelum kenaikan) dan kenaikan x.
• Kemudian ia menetapkan nilai ekspresi ke x, menimpa nilai tambah.

Jadi, urutan kejadiannya tampak seperti berikut (ini adalah bytecode yang didekompilasi aktual, seperti yang dihasilkan oleh javap -c, dengan komentar saya):

   8: iload_1 // Ingat nilai x saat ini di tumpukan
   9: iinc 1, 1 // Increment x (tidak mengubah tumpukan)
   12: istore_1 // Tulis nilai remeber dari stack ke x

Sebagai perbandingan, x = ++x:

   8: iinc 1, 1 // Peningkatan x
   11: iload_1 // Push nilai x ke stack
   12: istore_1 // Nilai pop dari tumpukan ke x

Ini terjadi karena nilai xtidak bertambah sama sekali.

x = x++;

setara dengan

int temp = x;
x++;
x = temp;

Penjelasan:

Mari kita lihat kode byte untuk operasi ini. Pertimbangkan kelas sampel:

class test {
    public static void main(String[] args) {
        int i=0;
        i=i++;
    }
}

Sekarang menjalankan disassembler kelas pada ini kita dapatkan:

$ javap -c test
Compiled from "test.java"
class test extends java.lang.Object{
test();
  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_0
   1:    istore_1
   2:    iload_1
   3:    iinc    1, 1
   6:    istore_1
   7:    return
}

Sekarang Java VM berbasis stack yang berarti untuk setiap operasi, data akan didorong ke stack dan dari stack, data akan muncul untuk melakukan operasi. Ada juga struktur data lain, biasanya array untuk menyimpan variabel lokal. Variabel lokal diberikan id yang hanya indeks ke array.

Mari kita lihat mnemonik dalam main()metode:

• iconst_0: Nilai konstan 0 didorong ke stack.
• istore_1: Elemen teratas stack muncul dan disimpan dalam variabel lokal dengan indeks 1
  yang x.
• iload_1: Nilai di lokasi 1yang merupakan nilai x tersebut 0, didorong ke dalam tumpukan.
• iinc 1, 1: Nilai di lokasi memori 1bertambah dengan 1. Jadi xsekarang menjadi 1.
• istore_1: Nilai di bagian atas tumpukan disimpan ke lokasi memori 1. Itu 0ditugaskan untuk x menimpa nilainya yang bertambah.

Oleh karena itu nilai xtidak berubah yang mengakibatkan infinite loop.

1. Notasi awalan akan menambah variabel SEBELUM ekspresi dievaluasi.
2. Notasi postfix akan bertambah SETELAH evaluasi ekspresi.

Namun " =" memiliki prioritas operator lebih rendah daripada "++ ".

Jadi x=x++;sebaiknya evaluasi sebagai berikut

1. x siap untuk penugasan (dievaluasi)
2. x bertambah
3. Nilai sebelumnya yang xditugaskan ke x.

Tidak ada jawaban yang cukup tepat, jadi begini:

Saat Anda menulis int x = x++, Anda tidak menetapkan xuntuk menjadi dirinya sendiri pada nilai baru, Anda ditugaskan xuntuk menjadi nilai balik x++ekspresi. Yang kebetulan merupakan nilai asli x, seperti yang ditunjukkan dalam jawaban Colin Cochrane .

Untuk bersenang-senang, uji kode berikut:

public class Autoincrement {
        public static void main(String[] args) {
                int x = 0;
                System.out.println(x++);
                System.out.println(x);
        }
}

Hasilnya akan

0
1

Nilai balik dari ekspresi adalah nilai awal x, yaitu nol. Tetapi kemudian, ketika membaca nilai x, kami menerima nilai yang diperbarui, yaitu satu.

Sudah dijelaskan dengan baik oleh yang lain. Saya hanya menyertakan tautan ke bagian spesifikasi Java yang relevan.

x = x ++ adalah ekspresi. Java akan mengikuti urutan evaluasi . Pertama akan mengevaluasi ekspresi x ++, yang akan menambah x dan menetapkan nilai hasil ke nilai x sebelumnya . Kemudian akan menetapkan hasil ekspresi ke variabel x. Pada akhirnya, x kembali pada nilai sebelumnya.

Pernyataan ini:

x = x++;

mengevaluasi seperti ini:

1. Dorong xke tumpukan;
2. Penambahan x;
3. Muncul xdari tumpukan.

Jadi nilainya tidak berubah. Bandingkan dengan:

x = ++x;

yang dievaluasi sebagai:

1. Penambahan x;
2. Dorong xke tumpukan;
3. Muncul xdari tumpukan.

Yang Anda inginkan adalah:

while (x < 3) {
  x++;
  System.out.println(x);
}

Jawabannya sangat mudah. Ini ada hubungannya dengan urutan hal-hal yang dievaluasi. x++mengembalikan nilai xlalu menambahkan x.

Konsekuensinya, nilai ekspresi x++adalah 0. Jadi, Anda menetapkan x=0setiap kali dalam lingkaran. Tentu saja x++menambah nilai ini, tetapi itu terjadi sebelum penugasan.

Dari http://download.oracle.com/javase/tutorial/java/nutsandbolts/op1.html

Operator kenaikan / penurunan dapat diterapkan sebelum (awalan) atau setelah (postfix) operan. Hasil kode ++; dan ++ hasil; keduanya akan berakhir dengan hasil yang bertambah satu. Satu-satunya perbedaan adalah bahwa versi awalan (hasil ++) mengevaluasi ke nilai yang meningkat, sedangkan versi postfix (hasil ++) mengevaluasi ke nilai asli . Jika Anda hanya melakukan kenaikan / penurunan sederhana, tidak masalah versi mana yang Anda pilih. Tetapi jika Anda menggunakan operator ini di bagian dari ekspresi yang lebih besar, yang Anda pilih dapat membuat perbedaan yang signifikan.

Untuk menggambarkan, coba yang berikut ini:

    int x = 0;
    int y = 0;
    y = x++;
    System.out.println(x);
    System.out.println(y);

Yang akan mencetak 1 dan 0.

Anda secara efektif mendapatkan perilaku berikut.

1. ambil nilai x (yaitu 0) sebagai "hasil" dari sisi kanan
2. menambah nilai x (jadi x sekarang 1)
3. tetapkan hasil dari sisi kanan (yang disimpan sebagai 0) ke x (x sekarang 0)

Gagasannya adalah bahwa operator pasca kenaikan (x ++) menambah variabel yang dipertanyakan SETELAH mengembalikan nilainya untuk digunakan dalam persamaan yang digunakan.

Sunting: Menambahkan sedikit karena komentar. Anggap saja seperti berikut.

x = 1;        // x == 1
x = x++ * 5;
              // First, the right hand side of the equation is evaluated.
  ==>  x = 1 * 5;    
              // x == 2 at this point, as it "gave" the equation its value of 1
              // and then gets incremented by 1 to 2.
  ==>  x = 5;
              // And then that RightHandSide value is assigned to 
              // the LeftHandSide variable, leaving x with the value of 5.

Anda tidak benar-benar membutuhkan kode mesin untuk memahami apa yang terjadi.

Menurut definisi:

1. Operator penugasan mengevaluasi ekspresi sisi kanan, dan menyimpannya dalam variabel sementara.

   1.1. Nilai x saat ini disalin ke variabel sementara ini

   1.2. x bertambah sekarang.

2. Variabel sementara kemudian disalin ke sisi kiri ekspresi, yang kebetulan x! Jadi itu sebabnya nilai lama x lagi disalin ke dalam dirinya sendiri.

Ini sangat sederhana.

Ini karena tidak pernah bertambah dalam kasus ini. x++akan menggunakan nilai itu terlebih dahulu sebelum bertambah seperti pada kasus ini akan seperti:

x = 0;

Tetapi jika Anda melakukan ++x;ini akan meningkat.

Nilai tetap pada 0 karena nilainya x++adalah 0. Dalam hal ini tidak masalah jika nilai xmeningkat atau tidak, tugas x=0dijalankan. Ini akan menimpa nilai kenaikan sementara x(yaitu 1 untuk "waktu yang sangat singkat").

Ini berfungsi seperti yang Anda harapkan. Perbedaan antara awalan dan postfix.

int x = 0; 
while (x < 3)    x = (++x);

Pikirkan x ++ sebagai pemanggilan fungsi yang "mengembalikan" apa X sebelum kenaikan (itulah mengapa ini disebut kenaikan pasca).

Jadi urutan operasi adalah:
1: cache nilai x sebelum incrementing
2: increment x
3: kembalikan nilai yang di-cache (x sebelum di-incremented)
4: nilai return ditugaskan ke x

Ketika ++ berada di rhs, hasilnya dikembalikan sebelum angkanya bertambah. Ubah ke ++ x dan itu akan baik-baik saja. Java akan mengoptimalkan ini untuk melakukan operasi tunggal (penugasan x ke x) daripada kenaikan.

Sejauh yang saya bisa lihat, kesalahan itu terjadi, karena penugasan mengesampingkan nilai yang bertambah, dengan nilai sebelum kenaikan, yaitu ia membatalkan kenaikan.

Secara khusus, ekspresi "x ++", memiliki nilai 'x' sebelum kenaikan dibandingkan dengan "++ x" yang memiliki nilai 'x' setelah penambahan.

Jika Anda tertarik untuk menyelidiki bytecode, kami akan melihat tiga baris yang dimaksud:

 7:   iload_1
 8:   iinc    1, 1
11:  istore_1

7: iload_1 # Akan meletakkan nilai variabel lokal ke-2 di stack
8: iinc 1,1 # akan menambah variabel lokal ke-2 dengan 1, perhatikan bahwa ia membiarkan stack tidak tersentuh!
9: istore_1 # Akan memunculkan bagian atas tumpukan dan menyimpan nilai elemen ini ke variabel lokal ke-2
(Anda dapat membaca efek dari setiap instruksi JVM di sini )

Inilah sebabnya mengapa kode di atas akan berulang tanpa batas, sedangkan versi dengan ++ x tidak akan. Bytecode untuk ++ x akan terlihat sangat berbeda, sejauh yang saya ingat dari kompiler Java 1.3 yang saya tulis sedikit lebih dari setahun yang lalu, bytecode harus seperti ini:

iinc 1,1
iload_1
istore_1

Jadi, hanya menukar dua baris pertama, ubah semantik sehingga nilai tertinggal di atas tumpukan, setelah kenaikan (yaitu 'nilai' ekspresi) adalah nilai setelah kenaikan.

    x++
=: (x = x + 1) - 1

Begitu:

   x = x++;
=> x = ((x = x + 1) - 1)
=> x = ((x + 1) - 1)
=> x = x; // Doesn't modify x!

Sedangkan

   ++x
=: x = x + 1

Begitu:

   x = ++x;
=> x = (x = x + 1)
=> x = x + 1; // Increments x

Tentu saja hasil akhirnya adalah sama dengan hanya x++;atau ++x;pada baris dengan sendirinya.

 x = x++; (increment is overriden by = )

karena pernyataan di atas x tidak pernah mencapai 3;

Saya bertanya-tanya apakah ada sesuatu di spec Java yang secara tepat mendefinisikan perilaku ini. (Implikasi yang jelas dari pernyataan itu adalah bahwa saya terlalu malas untuk memeriksa.)

Catatan dari bytecode Tom, garis kuncinya adalah 7, 8 dan 11. Baris 7 memuat x ke dalam tumpukan perhitungan. Peningkatan baris 8 x. Baris 11 menyimpan nilai dari tumpukan kembali ke x. Dalam kasus normal di mana Anda tidak menetapkan nilai kembali ke diri mereka sendiri, saya tidak berpikir akan ada alasan mengapa Anda tidak dapat memuat, menyimpan, lalu menambah. Anda akan mendapatkan hasil yang sama.

Seperti, misalkan Anda memiliki kasus yang lebih normal di mana Anda menulis sesuatu seperti: z = (x ++) + (y ++);

Apakah itu dikatakan (pseudocode to skip technicalities)

load x
increment x
add y
increment y
store x+y to z

atau

load x
add y
store x+y to z
increment x
increment y

harus tidak relevan. Entah implementasi harus valid, saya akan berpikir.

Saya akan sangat berhati-hati dalam menulis kode yang tergantung pada perilaku ini. Ini terlihat sangat tergantung pada implementasi, antara-celah-dalam-spesifikasi bagi saya. Satu-satunya waktu yang akan membuat perbedaan adalah jika Anda melakukan sesuatu yang gila, seperti contoh di sini, atau jika Anda memiliki dua utas berjalan dan bergantung pada urutan evaluasi dalam ekspresi.

Saya pikir karena di Java ++ memiliki prioritas lebih tinggi daripada = (tugas) ... Apakah itu? Lihatlah http://www.cs.uwf.edu/~eelsheik/cop2253/resources/op_precedence.html ...

Cara yang sama jika Anda menulis x = x + 1 ... + memiliki prioritas lebih tinggi daripada = (tugas)

The x++ekspresi mengevaluasi ke x. Bagian itu ++mempengaruhi nilai setelah evaluasi , bukan setelah pernyataan . jadi x = x++secara efektif diterjemahkan ke dalam

int y = x; // evaluation
x = x + 1; // increment part
x = y; // assignment

Sebelum menambah nilai satu, nilai ditugaskan ke variabel.

Itu terjadi karena posnya bertambah. Ini berarti bahwa variabel bertambah setelah ekspresi dievaluasi.

int x = 9;
int y = x++;

x sekarang 10, tetapi y adalah 9, nilai x sebelum dinaikkan.

Lihat lebih lanjut di Definisi Peningkatan Pasca .

Periksa kode di bawah ini,

    int x=0;
    int temp=x++;
    System.out.println("temp = "+temp);
    x = temp;
    System.out.println("x = "+x);

output akan menjadi,

temp = 0
x = 0

post incrementberarti kenaikan nilai dan kembalikan nilai sebelum kenaikan . Itulah sebabnya nilai tempadalah 0. Jadi bagaimana jika temp = idan ini dalam satu lingkaran (kecuali untuk baris kode pertama). seperti dalam pertanyaan !!!!

Operator kenaikan diterapkan ke variabel yang sama seperti yang Anda tetapkan. Itu meminta masalah. Saya yakin Anda dapat melihat nilai variabel x Anda saat menjalankan program ini .... itu harus menjelaskan mengapa loop tidak pernah berakhir.