Java 赋值运算符执行

在 Java 中，我知道赋值计算为右操作数的值，所以像 x == (y = x)这样的语句计算为 true。

但是，此代码输出 false。

public static void main(String[]args){
String x = "hello";
String y = "goodbye";
System.out.println(x.equals(x = y));
}

为什么会这样？在我的理解中，它首先计算 (x = y)，它将 y的值赋给 x，然后返回 y的值。然后计算 x.equals(y)，它应该是 true，因为 x和 y现在应该共享相同的引用，但是我得到的是 false。

Screenshot showing the source and that the output is "false"

这里发生了什么？

4155 次浏览
小开
最佳答案

First of all: that's an interesting question, but should never come up in "real code", as assigning to the variable you call in the very same line is confusing even if you know how it works.

What happens here is these 3 steps:

  1. figure out which object to call the method on (i.e. evaluate the first x, this will result in a reference to the String "hello")
  2. figure out the parameters (i.e. evaluate x = y, which will change x to point to the String "goodbye" and also return a reference to that String)
  3. call the method equals on the result of #1 using the result of #2 as the parameter (which will be references to the Strings "hello" and "goodbye" respectively).

Looking at the byte code produced for that method makes it clear (assuming you're fluent in Java bytecode):

     0: ldc           #2                  // String hello
2: astore_1
3: ldc           #3                  // String goodbye
5: astore_2
6: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
9: aload_1
10: aload_2
11: dup
12: astore_1
13: invokevirtual #5                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
16: invokevirtual #6                  // Method java/io/PrintStream.println:(Z)V
19: return

Line #9 is step 1 above (i.e. evaluates x and remembers the value).

Line #10-12 is step 2. It loads y, duplicates it (once for assigning, once for the return value of the assignment expression) and assigns it to x.

Line #13 invokes equals on the result computed in Line #9 and the result of Lines #10-12.

小开

x=y in the parenthesis means that expression (x=y) is now goodbye, while the outer x in x.equals holds the value hello

小开

It's important to remember that a String in java is an object, and therefore a reference. When you call

x.equals(...)

It is checking if the value at the location currently referenced by x is equal to what you are passing in. Inside, you are changing the value that x is referencing, but you are still calling equals with the original reference (the reference to "hello"). So, right now your code is comparing to see if "hello" is equal to "goodbye", which it clearly is not. After this point, if you use x again, it will result in a reference to the same value as y.

小开

Reimus gave the correct answer, but I'd like to elaborate.

In Java (and most languages) the convention is variable goes on the left, assignment on the right.

Let's Break it down:

String x = "hello";
//x <- "hello"


String y = "goodbye";
//y <- "goodbye";

For debugging purposes as well as code readability, it's always a good practice to split up your lines so that they only do one thing.

System.out.println(x.equals(x = y)); //Compound statement

Here, x.equals(...) is called on the original reference to x, or "hello", it is updated for the second reference.

I would write this as (and this will give you your expected answer):

x = y;
// x <- y = "goodbye"


boolean xEqualsX = x.equals(x);
// xEqualsX <- true


System.out.println(xEqualsX);
// "true"

Now this seems obvious that it should behave this way, but it's also really easy to see exactly what is going on in each line, which is something you should strive for.

小开

Good question! And the JLS has the answer...

§15.12.4.1 (Example 15.12.4.1-2). Evaluation Order During Method Invocation:

As part of an instance method invocation, there is an expression that denotes the object to be invoked. This expression appears to be fully evaluated before any part of any argument expression to the method invocation is evaluated.

So, in:

String x = "hello";
String y = "goodbye";
System.out.println(x.equals(x = y));

the occurrence of x before .equals is evaluated first, before the argument expression x = y.

Therefore,  a reference to the string  hello  is remembered as the target reference before the local variable x is changed to refer to the string goodbye. As a result, the equals method is invoked for target object hello with argument goodbye, so the result of the invocation is false.

小开

I see the question in layman terms as "hello".equals("goodbye"). So it returns false.

小开

It is seeing if x.equals (assign x to y, returns true always) so basically x.equals(true)

小开

I have tried your question in eclipse your both expression are correct. 1) x == (y = x) evaluate to true it is true because value of x assign to y which is 'hello' then x and y compare they will same so result will true

2) x.equal(x = y) it is false because value of y assign to x which is goodbye then x and x compare their value will be different so result will be false

小开

In java String is a class.

String x = "hello";
String y = "goodbye";

is a two different String which refer to two different value which is not same and if you compare 

 System.out.println(x.equals(x = y));
//this compare value (hello and goodbye) return true


System.out.println(x == (y = x));
// this compare reference of an object (x and y) return false

提交答案