Lamby’s Blog

not entirely unlike a blog

1. mullet 27.12.07 / 3am

   This is vaguely interesting. A quick javap -c on Test1 tells us:

      0:   getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
      3:   ldc     #3; //String True
      5:   invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
      8:   return

   In otherwords javac is concluding that “use” is always equivalent to “use” (which I guess is a form of constant folding) and applying branch elimination to the inline if.

   Clearly realising that ‘new String(”mention”)’ is equivalent to ‘new String(”mention”)’ is too hard or computationally expensive for javac to do.
2. Lamby 27.12.07 / 11am

   Aw, you’re so close; but by “always”, I genuinely mean always. Also, your answer is implementation specific.
3. RobRob 27.12.07 / 12pm

   *thinks he remembers some magic about this from somewhere*,

   doesn’t java have some magical pool of constant string objects? so, i’d guess if it finds a constant string that is already in the pool, it doesn’t bother creating a new one and just points at the already created string object. (ie: both are the same string object)

   as for why the second bit is always false, they’re different string objects innit.

   (do i get a prize?)
4. Lamby 27.12.07 / 7pm

   @RobRob
   That’s not a particularly convincing explanation.. You posit that it doesn’t bother creating a new string when there’s one already in the pool, but then you claim that they are different strings.. My question is really about the connection between the two: why one but not the other?
5. JT 07.01.08 / 3pm

   Extending frrobrob om - in the first instance, the two are defined at the compile time and would be the same reference in the “string pool”. The compiler would have to set these to being the same if pointer 1== pointer 1, if not actually compile all the way down and remove the if statement completely (as mullet observes))

   In the second case, they string might be the same in the string pool, but the new keyword means that the reference to them are different. If you consider the reference to be effectively a pointer, the two are pointing at the same string, but they themselves are not the same.
6. Ed Davies 24.01.08 / 12pm

   The second case is obvious, new creates new objects each time as it doesn’t know about classes which have mostly pure value semantics (two strings with the same characters are indistinguishable except by “==” (and “!=”, of course)). The first is a bit more subtle - you have to know that all the string constants are in the String#intern pool and so there’s a single instance for each character sequence, sort of like if you’d written “new String(”use”).intern() == new String(”use”).intern()” which would return true each time.
7. Ryan Tomayko 24.01.08 / 3pm

   From Section 3.10.5 of the Java Language Specification:

   Each string literal is a reference (§4.3) to an instance (§4.3.1, §12.5) of class String (§4.3.3). String objects have a constant value. String literals-or, more generally, strings that are the values of constant expressions (§15.28)-are “interned” so as to share unique instances, using the method String.intern.

   Strings created with new String are new object instances and therefore have a different identity. Inline strings are interned and thus have the same identity.
8. 0x01 11.02.08 / 12pm

   False …

   System.out.println((”use”.equals(”use”)) ? “True” : “False”); == true
   System.out.println((new String(”mention”).equals(”mention”)) ? “True” : “False”);

   Returns true.

Powered by Hemingway flavored Wordpress.

Entries RSS Comments RSS