Строковое литералы и отношение объектов в Java [дубликат]

Когда компилятор оптимизирует ваши строковые литералы, он видит, что оба s1 и s2 имеют одинаковое значение и, следовательно, вам нужен только один строковый объект. Это безопасно, потому что String неизменна в Java.

String s1="Java";
String s2="Java";
System.out.println(s1== s2);

Это дает результат true, потому что s1 и s2 указывают на один и тот же объект.

String Pool - это механизм, который все уже определенная строка хранится в некотором «пуле», и перед созданием нового компилятора объекта String проверяет, определена ли такая строка.

Пример.

Первый пример

String s1 = "FirstString";
String s2 = "FirstString";

 if(s1 == s2) {
   //This condition matched true because java don't make separate object for these two string. Both strings point to same reference.
 }

Второй пример

String s1= "FirstString";
String s2 = new String("FirstString");

if(s1.equals(s2)) {
  //This condition true because same content.
}

if(s1 == s2) {
  //This condition will be false because in this java allocate separate reference for both of them
}

Заключение: Java проверяет, существует ли строка или нет. Если мы создадим объект второй строки с использованием нового и имеем разный контент, тогда он создает объект и назначает другую ссылку, а в случае Если мы не создаем объект с использованием нового и не будем иметь один и тот же контент, тогда его назначение будет иметь ту же ссылку, что и первая строка, .

ДА, Эндрю Хейр ответил на переполнение стека по этой ссылке https://stackoverflow.com/a/2486195/4835894 .

В принципе, строка intern pool позволяет среде выполнения сохранять память, сохраняя неизменяемые строки в пуле, чтобы области приложения могли повторно использовать экземпляры общих строк вместо создания нескольких экземпляров.

String s1="Java";
String s2="Java";
My question is whether these two references point to the same memory location  

Dumb citing §3.10.5 Спецификации языка Java :

Строковый литерал является ссылкой на экземпляр класса String ( §4.3.1 , §4.3.3 ).

Кроме того, строковый литерал всегда ссылается на тот же экземпляр класса String. Это связано с тем, что строковые литералы, или, в более общем смысле, строки, которые являются значениями константных выражений ( §15.28 ), «интернированы», чтобы обмениваться уникальными экземплярами, используя метод String.intern.

И прочитайте комментарии к примеру кода там:

Этот пример иллюстрирует шесть пунктов:

• Литеральные строки в одном и том же класс (§8) в том же пакете (§7) представляют ссылки на один и тот же объект String (§4.3.1).
• Литеральные строки в разных классах в одном пакете представляют ссылки на один и тот же объект String .
• Литеральные строки в разных классах в разных пакетах также представляют ссылки на один и тот же объект String.
• Строки, вычисленные с помощью константных выражений (§15.28), вычисляются во время компиляции, а затем обрабатываются как если они были литералами.
• Строки, вычисленные путем конкатенации во время выполнения, вновь создаются и, следовательно, различны.
• Результат явно interni ng вычисленная строка является той же строкой, что и любая ранее существовавшая буквальная строка с тем же содержимым.

Добавление к другим: новое ключевое слово всегда заставляет создавать новый объект. Если вы объявляете, как показано ниже:

String s1 = "some";
String s2 = "some";

Затем, используя механизм String Pooling, обе ссылки s1 и s2 будут ссылаться на один и тот же объект String со значением «some».

Когда у вас есть

String str1 = new String("BlaBla");  //In the heap!
String str2 = new String("BlaBla");  //In the heap!

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

Но если у вас есть:

String str1 = "BlaBla";        
String str2 = "BlaBla";

, то у вас подразумеваемая конструкция. Литералы двух строк используют одно и то же хранилище, если они имеют одинаковые значения, потому что Java сохраняет память одних и тех же строк! (Строки, имеющие одинаковое значение)