なぜこれが無限ループになるのですか？

私は次のコードを持っています：

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

私たちは、彼がちょうど書かれている必要があります知っているx++かx=x+1、しかしにx = x++それべき最初の属性x自体に、後でそれをインクリメントします。なぜ価値xとして続けるの0ですか？

- 更新

バイトコードは次のとおりです。

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

}

理解しようとするための指示について読みます...

注：C＃ではキーワードをint使用して参照でパラメーターを渡すことができるため、元々は説明のためにこの回答にC＃コードを投稿しましたref。私はMutableInt、Googleで最初に見つけたクラスを使用して実際の合法的なJavaコードで更新することに決めましたref。それが答えを助けるか傷つけるかどうか私は本当にわかりません。私は個人的にはそれほど多くのJava開発を行っていません。したがって、この点を説明するためのもっと慣用的な方法が存在する可能性があることを私は知っています。

おそらく、それと同等の処理を行うメソッドを作成するx++と、これがより明確になります。

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

正しい？渡された値をインクリメントし、元の値を返します。これがポストインクリメント演算子の定義です。

次に、この動作がサンプルコードでどのように実行されるかを見てみましょう。

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

postIncrement(x)何をしますか？増分x、はい。そして、何を返しx た増分の前に。次に、この戻り値がに割り当てられxます。

したがって、割り当てられる値の順序は0、1、0の順になりますx。

上記を書き直すと、これはさらに明確になる可能性があります。

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.

x上記の割り当ての左側をで置き換えるとy、「最初にxがインクリメントされ、後でyに割り当てられることがわかります」という固執は、私を混乱させます。にx割り当てられているわけではありませんy。それは、以前に割り当てられた値x。本当に、注入yは上記のシナリオと何の違いもありません。私たちは単に持っています：

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.

ですからx = x++、xの値は実質的に変更されません。これにより、xの値は常にx ₀、次にx ₀ + 1、次にx _0になります。

更新：ちなみに、xインクリメント操作と上記の例の割り当ての「間に」1が割り当てられることを疑わないように、この中間値が実際に「存在する」ことを示す簡単なデモを一緒に示しましたが、実行中のスレッドで「見える」ことはありません。

デモはx = x++;ループで呼び出され、別のスレッドが継続的にの値をxコンソールに出力します。

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

以下は、上記のプログラムの出力の抜粋です。1と0の両方の不規則な発生に注意してください。

バックグラウンドスレッドを開始しています...
0
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1

x = x++ 次のように動作します：

• まず、式を評価しますx++。この式を評価すると、式の値（xインクリメント前の値）とインクリメントが生成されますx。
• その後、式の値をに割り当て、x増分した値を上書きします。

したがって、イベントのシーケンスは次のようになります（これは、によって生成された実際の逆コンパイルされたバイトコードjavap -cで、コメントが含まれています）。

   8：iload_1 //スタック内のxの現在の値を記憶する
   9：iinc 1、1 //インクリメントx（スタックを変更しない）
   12：istore_1 //記憶された値をスタックからxに書き込む

、比較のためにx = ++x：

   8：iinc 1、1 //インクリメントx
   11：iload_1 // xの値をスタックにプッシュします
   12：istore_1 //スタックからxに値をポップします

これは、の値xがまったく増分されないために発生します。

x = x++;

に相当

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

説明：

この操作のバイトコードを見てみましょう。サンプルクラスについて考えてみましょう。

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

これでクラス逆アセンブラを実行すると、次のようになります。

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

これでJava VMはスタックベースになり、各操作でデータがスタックにプッシュされ、スタックからデータがポップアウトして操作を実行します。また、別のデータ構造もあります。通常は、ローカル変数を格納するための配列です。ローカル変数には、配列のインデックスであるIDが与えられます。

メソッドのニーモニックを見てみましょうmain()：

• iconst_0：定数値0 がスタックにプッシュされます。
• istore_1：スタックの一番上の要素がポップアウトされ、インデックスで1
  あるローカル変数に格納されます x。
• iload_1：位置での値1の値でx あるが0、スタックにプッシュされます。
• iinc 1, 1：メモリ位置の値1はによって増分され1ます。だからx今になり 1ます。
• istore_1：スタックの最上位の値がメモリ位置に保存されます1。これは、増分された値0をx 上書きするために割り当てられます。

したがって、の値はx変化せず、無限ループになります。

1. プレフィックス表記は、式が評価される前に変数をインクリメントします。
2. Postfix表記は、式の評価後に増加します。

ただし、「=」は「」よりも演算子の優先順位が低くなってい++ます。

したがってx=x++;、次のように評価する必要があります

1. x 割り当ての準備（評価済み）
2. x 増加した
3. にx割り当てられたの以前の値x。

正解はどこにもないので、ここに行きます：

を記述しているときはint x = x++、xそれ自体が新しい値になるように割り当てるのではなくx、x++式の戻り値になるように割り当てます。これはx、Colin Cochraneの回答に示唆されているように、の元の値です。

楽しみのために、次のコードをテストします。

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

結果は

0
1

式の戻り値は、xゼロの初期値です。しかし、後で、の値を読み取るときにx、更新された値、つまり1を受け取ります。

それはすでに他の人によってよく説明されています。関連するJava仕様セクションへのリンクのみを含めます。

x = x ++は式です。Javaは評価順序に従います。最初に式x ++を評価し、x をインクリメントして、結果の値を以前のxの値に設定します。次に、式の結果を変数xに割り当てます。最後に、xは以前の値に戻ります。

この文：

x = x++;

このように評価します：

1. xスタックにプッシュします。
2. 増分x;
3. xスタックからポップします。

したがって、値は変更されません。それと比較してください：

x = ++x;

これは次のように評価されます：

1. 増分x;
2. xスタックにプッシュします。
3. xスタックからポップします。

あなたが欲しいのは：

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

答えはかなり簡単です。物事が評価される順序と関係があります。x++値を返し、x増分しますx。

したがって、式の値x++は0です。したがってx=0、ループ内で毎回割り当てています。確かにx++この値は増加しますが、それは割り当ての前に起こります。

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

インクリメント/デクリメント演算子は、オペランドの前（前置）または後（後置）に適用できます。コードresult ++; および++ result; 両方とも結果的に1ずつ増加します。唯一の違いは、接頭辞バージョン（++ result）は増分値に評価されるのに対し、postfixバージョン（結果++）は元の値に評価されることです。単純なインクリメント/デクリメントを実行しているだけの場合、どちらのバージョンを選択してもかまいません。ただし、より大きな式の一部でこの演算子を使用する場合、選択する式によって大きな違いが生じる可能性があります。

説明のために、次のことを試してください。

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

1と0を出力します。

次の動作を効果的に実行しています。

1. 右側の「結果」としてxの値（0）を取得
2. xの値をインクリメントします（xは1になりました）
3. 右側（0として保存された）の結果をxに割り当てます（xは0になりました）

ポストインクリメント演算子（x ++）は、問題の変数をインクリメントしてから、その変数を使用する方程式で使用するための値を返します。

編集：コメントのために少し追加します。次のように考えてください。

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.

何が起こっているのかを理解するために、マシンコードは実際には必要ありません。

定義によると：

1. 代入演算子は右辺式を評価し、それを一時変数に格納します。

   1.1。xの現在の値がこの一時変数にコピーされます

   1.2。xが増加します。

2. 次に、一時変数が式の左側にコピーされます。これは偶然xです。そのため、xの古い値が再びそれ自体にコピーされます。

とてもシンプルです。

これは、この場合は増分されないためです。x++この場合、次のようにインクリメントする前に、最初にその値を使用します。

x = 0;

しかし、++x;これを行うと、増加します。

の値は0であるため、値x++は0のままです。この場合、の値xが増加してもしなくても、割り当てx=0が実行されます。これにより、一時的に増加した値x（「非常に短い時間」の場合は1でした）が上書きされます。

これは、他の人が期待する方法で機能します。接頭辞と接尾辞の違いです。

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

x ++は、インクリメント前のXを「返す」関数呼び出しと考えてください（そのため、ポストインクリメントと呼ばれています）。

したがって、操作の順序は次のとおりです
。1：xの値をキャッシュしてからインクリメントする
2：xをインクリメントする
3：キャッシュされた値を返す（xがインクリメントされる前）
4：戻り値がxに割り当てられる

++がrhsにある場合、数値が増分される前に結果が返されます。++ xに変更すれば問題ありません。Javaは、増分ではなく単一の操作（xからxへの割り当て）を実行するようにこれを最適化します。

私が見る限り、インクリメント前の値でインクリメントされた値をオーバーライドする割り当てが原因で、エラーが発生します。つまり、インクリメントが元に戻されます。

具体的には、「x ++」式は、インクリメント後に「x」の値を持つ「++ x」とは対照的に、インクリメント前に「x」の値を持っています。

バイトコードの調査に関心がある場合は、問題の3行を見てみましょう。

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

7：iload_1＃2番目のローカル変数の値をスタックに入れます
8：iinc 1,1＃2番目のローカル変数を1だけインクリメントします。これにより、スタックはそのままになります。
9：istore_1＃スタックの最上部をポップし、この要素の値を2番目のローカル変数に保存します
（各JVM命令の効果はここで読むことができます）

このため、上記のコードは無限にループしますが、++ xを含むバージョンではループしません。++ xのバイトコードはかなり異なるはずです。1年以上前に書いた1.3 Javaコンパイラーから覚えている限り、バイトコードは次のようになります。

iinc 1,1
iload_1
istore_1

したがって、最初の2行を交換するだけで、インクリメント後にスタックの一番上に残った値（つまり、式の「値」）がインクリメント後の値になるようにセマンティクスを変更します。

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

そう：

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

一方

   ++x
=: x = x + 1

そう：

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

もちろん、最終的な結果は、1 x++;つだけの場合と同じ++x;です。

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

上記のステートメントのため、xは3に到達しません。

これの動作を正確に定義する何かがJava仕様にあるのだろうか。（そのステートメントの明らかな意味は、私がチェックするのが面倒すぎるということです。）

トムのバイトコードから、重要な行は7、8、11であることに注意してください。行7はxを計算スタックにロードします。行8はxを増分します。行11は、スタックからxに戻る値を格納します。自分自身に値を割り当てない通常のケースでは、ロード、保存、およびインクリメントできなかった理由はないと思います。同じ結果が得られます。

同様に、次のように記述した通常のケースがあるとします。z=（x ++）+（y ++）;

それが言ったかどうか（技術をスキップする疑似コード）

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

または

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

無関係である必要があります。どちらの実装も有効であるべきだと思います。

この振る舞いに依存するコードを書くことについては、私は非常に慎重になるでしょう。それは、実装に依存している、仕様間での仕様に非常によく似ています。ここでの例のようにクレイジーなことをした場合、または2つのスレッドを実行していて、式内の評価の順序に依存していた場合のみ、違いが生じます。

Java ++では=（代入）よりも優先順位が高いと思います... http://www.cs.uwf.edu/~eelsheik/cop2253/resources/op_precedence.htmlを見てください ...

同じようにx = x + 1 ... +と記述した場合、=（代入）よりも優先順位が高くなります。

x++式があると評価しますx。++一部は後の値に影響を与えた評価ではなく、後のステートメント。これx = x++を効果的に翻訳されます

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

値を1つインクリメントする前に、値が変数に割り当てられます。

それはポストインクリメントされているので起こっています。つまり、式が評価された後に変数がインクリメントされます。

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

xは10になりましたが、yは9で、インクリメントされる前のxの値です。

詳細については、Post Incrementの定義を参照してください。

以下のコードを確認してください、

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

出力は、

temp = 0
x = 0

post incrementは、値を増分し、増分前の値を返すことを意味します。そのため、値tempは0です。ではtemp = i、ループ内にある場合（コードの最初の行を除く）はどうでしょうか。質問のように!!!!

増分演算子は、割り当て先と同じ変数に適用されます。それは問題を求めています。このプログラムの実行中にx変数の値を確認できると思います。これにより、ループが終了しない理由が明確になります。