Почему intern () не работает с буквальным java?

Вы неправильно используете intern. intern не изменяет строковый объект, о котором он называется (строки в любом случае неизменяемы), но возвращается - каноническое представление этой строки, которое вы просто отбрасываете. Вместо этого вы должны присвоить его переменной и использовать эту переменную в своих проверках. Например.:

sj1 = sj1.intern();

Когда JVM впервые встречает строку new String(new char[] {'a', 'b', 'h', 'i'}) и вы вызываете для нее intern(), только что созданная ссылка становится канонической и сохраняется в пуле строковых констант. Затем "abhi" извлекается из пула констант - ваш канонический экземпляр был повторно использован.

Ваша проблема в том, что буквальный "java" существует в пуле константных строк до начала вашей программы - JVM просто имеет его там для некоторого использования. Следовательно, вызов intern() на new String(new char[] {'j', 'a', 'v', 'a'}) делает нет интернированием вашей ссылки. Вместо этого он возвращает уже существующее каноническое значение из пула констант, а вы с радостью игнорируете возвращаемое значение.

Не игнорируйте возвращаемое значение, а используйте его. Вы никогда не узнаете, не находилась ли ваша «определенно оригинальная» строка в постоянном пуле с момента запуска JVM. В любом случае, все это зависит от реализации, вы должны либо всегда использовать ссылки, возвращаемые методом intern(), либо никогда. Не смешивайте их.

В OpenJDK 1.8.0u151 и OpenJDK 9.0.4

char[] cj = {'j','a','v','a'};
String sj = new String(cj);
sj.intern();
String sc = "java";
System.out.println(sj == sc); 

печатает true. Однако эта проверка == зависит от того, какие String были интернированы в пул строк перед выполнением String sc = "java". Поскольку во время компиляции константы String интернированы компилятором Java, ссылка sc теперь указывает на "java" в пуле строк, который был помещен туда с sj.intern() с использованием ссылки s1.

Если вы попытаетесь выделить String "java" раньше, например:

String before = "java"; // interned before by compiler
char[] cj = {'j','a','v','a'};
String sj = new String(cj);
sj.intern();
String sc = "java";
System.out.println(sj == sc);

код теперь будет печатать false, поскольку sj.intern() теперь не будет иметь побочных эффектов, поскольку "java" String был интернирован ранее.

Чтобы отладить проблему, проверьте, что находится внутри интернированного пула строк, прежде чем вы дойдете до неудачной проверки. Это может зависеть от поставщика или версии вашей JVM.

Кто-то может возразить, что вызывать intern() только из-за побочного эффекта добавления значения в пул строк бессмысленно. Запись sj = sj.intern() - правильный способ интернировать String.

ответ Петра Янечека почти наверняка правильный (+1 там).

На самом деле доказывая это сложно, потому что большая часть пула строк находится в самой JVM, и вряд ли можно было бы получить к нему доступ без настроенной виртуальной машины.

Но вот еще несколько доказательств:

public class TestInternEx
{
    public static void main(String[] args)
    {
        char[] c1 = { 'a', 'b', 'h', 'i' };
        String s1 = new String(c1);
        String s1i = s1.intern();
        String s1s = "abhi";
        System.out.println(System.identityHashCode(s1));
        System.out.println(System.identityHashCode(s1i));
        System.out.println(System.identityHashCode(s1s));
        System.out.println(s1 == s1s);// true

        char[] cj =
        { 'j', 'a', 'v', 'a' };
        String sj = new String(cj);
        String sji = sj.intern();
        String sjs = "java";
        System.out.println(System.identityHashCode(sj));
        System.out.println(System.identityHashCode(sji));
        System.out.println(System.identityHashCode(sjs));
        System.out.println(sj == sjs);// false

        char[] Cj = { 'J', 'A', 'V', 'A' };
        String Sj = new String(Cj);
        String Sji = Sj.intern();
        String Sjs = "JAVA";
        System.out.println(System.identityHashCode(Sj));
        System.out.println(System.identityHashCode(Sji));
        System.out.println(System.identityHashCode(Sjs));
        System.out.println(Sj == Sjs);// true

        char[] ct =
        { 't', 'r', 'u', 'e' };
        String st = new String(ct);
        String sti = st.intern();
        String sts = "true";
        System.out.println(System.identityHashCode(st));
        System.out.println(System.identityHashCode(sti));
        System.out.println(System.identityHashCode(sts));
        System.out.println(st == sts);// false


    }
}

Программа выводит для каждой строки идентификационный хэш-код

• строка, созданная с помощью new String
• строка, возвращаемая String#intern
• строка, заданная как литерал

Результат примерно такой:

366712642
366712642
366712642
true
1829164700
2018699554
2018699554
false
1311053135
1311053135
1311053135
true
118352462
1550089733
1550089733
false

Можно видеть, что для строки "java" хэш-код new String равен разные от хеш-кода строкового литерала, но последний является одно и тоже как результат вызова String#intern - это означает, что String#intern действительно вернул строку, которая глубоко идентичен самому буквальному.

Я также добавил String "true" в качестве еще одного тестового примера. Он показывает такое же поведение, потому что можно предположить, что строка true уже появилась раньше при загрузке виртуальной машины.