...

...

See the JLS,
http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5313
for the definition, for Java purposes, of "constant expression".

" String ".trim() is composed using an operation, method invocation,
that is not on the list, so it is not a constant expression of type String.

Patricia

When comparing String values, you must use the .equals method

" String ".trim().equals("String") // This is true
" String ".trim() == "String" // This may or may not be true, depending
on a lot of things.

The problem here is the difference between reference equality and
object equality.

Reference equality basically says that reference's to the objects are
both the same value (They both point to the same place in virtual
memory, sort-of-speak).  Object equality says that the semantec meaning
of the object is the same, even if they are two different objects...

" String ".trim() will return a String object who's value is "String",
but there may be (and probably is) another "String" object somewhere
else.  Then your == is like asking "Is this apple the same apple as
that apple?"  They look the same, but they are indeed different
objects.

I hope this helps.

Daniel.

This is the old pointer identity versus value identity bug.

If you used " String ".trim().equals( "String"), you'd find it would work.
The == operator tests pointer identity (for anything except primitives)
and so fails if you have two different Strings both with the print
value "String".

   Here's what I suspect is going on:

   In the first program, 4 strings are added to the constant pool: " String
", "String", "Equal" and "Not Equal". If you actually look at the source
code for the String class, you'll see that it holds not only a character
buffer, but also an offset and a length, so that two strings could share the
same buffer. So when you call trim() on " String ", what happens is that the
trim() method returns a new String object, which uses the same buffer, but
increases the offset by one, and decreases the length by two.

   When you compare the two strings using ==, the two strings are clearly
different objects, and so "Not Equal" is printed to the console.

   In the second program, 3 strings are added to the constant pool:
"String", "Equal" and "Not Equal". The same String object is used for both
instances of "String" which appear in the source code. When you call
toString() on "String", it just returns *this*, rather than creating a new
String object, and therefore you have two references to the same object,
which is why the == operator yields true, an "Equal" is returned.

   - Oliver