intern() behaving differently in Java 6 and Java 7

It seems that JDK7 process intern in a different way as before.
I tested it with build 1.7.0-b147 and got "both are equal", but when executing it (same bytecode) with 1,6.0_24 I do not get the message.
It also depends where the String b2 =... line is located in the source code. The following code also does not output the message:

class Test {   public static void main(String... args) {      String s1 = "Good";      s1 = s1 + "morning";      String s2 = "Goodmorning";      System.out.println(s1.intern());  //just changed here s1.intern() and the if condition runs true         if(s1 == s2) {         System.out.println("both are equal");      } //now it works.   }}

it seems like intern after not finding the String in its pool of strings, inserts the actual instance s1 into the pool. The JVM is using that pool when s2 is created, so it gets the same reference as s1 back. On the other side, if s2 is created first, that reference is stored into the pool.
This can be a result of moving the interned Strings out from the permanent generation of the Java heap.

Found here: Important RFEs Addressed in JDK 7

In JDK 7, interned strings are no longer allocated in the permanent generation of the Java heap, but are instead allocated in the main part of the Java heap (known as the young and old generations), along with the other objects created by the application. This change will result in more data residing in the main Java heap, and less data in the permanent generation, and thus may require heap sizes to be adjusted. Most applications will see only relatively small differences in heap usage due to this change, but larger applications that load many classes or make heavy use of the String.intern() method will see more significant differences.

Not sure if that is a bug and from which version... The JLS 3.10.5 states

The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

so the question is how pre-existing is interpreted, compile-time or execute-time: is "Goodmorning" pre-existing or not?
I prefer the way it WAS implemented before 7...

Let's omit unnecessary details from the example:

class Test {    public static void main(String... args) {        String s1 = "Good";        s1 = s1 + "morning";        System.out.println(s1 == s1.intern()); // Prints true for jdk7, false - for jdk6.    }}

Let's consider String#intern as a black box. Based on a few test cases run, I would conclude that implementation is as following:

Java 6:
if the pool contains object equals to this, then return reference to that object,else create new string (equal to this), put to the pool, and return reference to that created instance.

Java 7:
if the pool contains object equals to this, then return reference to that object,else put this to the pool, and return this.

Neither Java 6 nor Java 7 breaks the contract of the method.

It seems that new intern method behavior was a result of the fix of this bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6962931.

== compares the references. The intern method makes sure strings with the same value have the same reference.

The javadoc for the String.intern method explains:

public String intern()

Returns a canonical representation for the string object.

A pool of strings, initially empty, is maintained privately by theclass String.

When the intern method is invoked, if the pool already contains astring equal to this String object as determined by the equals(Object)method, then the string from the pool is returned. Otherwise, thisString object is added to the pool and a reference to this Stringobject is returned.

It follows that for any two strings s and t, s.intern() ==t.intern() is true if and only if s.equals(t) is true.

All literal strings and string-valued constant expressions areinterned. String literals are defined in §3.10.5 of the Java LanguageSpecification

Returns: a string that has the same contents as this string, but isguaranteed to be from a pool of unique strings.

So without interning the compiler looks at the constants in the java code and builds its constant pool from that. There is a different pool maintained by the String class, and interning checks the string passed in against the pool and makes sure the reference is unique (so that == will work).