Как мы получаем доступ к методам String, даже если мы не используем новое ключевое слово? [Дубликат]

String a = "abc"; // 1 Object: "abc" added to pool

String b = "abc"; // 0 Object: because it is already in the pool

String c = new String("abc"); // 1 Object

String d = new String("def"); // 1 Object + "def" is added to the Pool

String e = d.intern(); // (e==d) is "false" because e refers to the String in pool

String f = e.intern(); // (f==e) is "true" 

//Total Objects: 4 ("abc", c, d, "def").

Надеюсь, что это несколько сомнений. :)

Строки являются «специальными» объектами в Java. Разработчики Java мудро решили, что Strings используются так часто, что им нужен собственный синтаксис, а также стратегия кэширования. Когда вы объявляете строку, говоря:

String myString = "something";

myString является ссылкой на объект String со значением «something». Если вы позже объявите:

String myOtherString = "something";

Java достаточно умен, чтобы понять, что myString и myOtherString одинаковы и будут хранить их в глобальной таблице String в качестве одного и того же объекта. Он полагается на то, что вы не можете изменять Strings для этого. Это уменьшает объем требуемой памяти и ускоряет сравнение.

Если вместо этого вы напишете

String myOtherString = new String("something");

Java создаст для вас совершенно новый объект, отличный от myString объект.

Это ярлык. Это было не так, но Java изменил его.

Этот FAQ говорит об этом кратко. Об этом также говорит руководство по спецификации Java. Но я не могу найти его в Интернете.

Невозможно создать новую строку с

String s = new String("I'm a new String");

. Обычная нотация s = "new String"; - более или менее удобный ярлык - который следует использовать по соображениям производительности, за исключением тех редких случаев, где вам действительно нужны строки, которые подходят для уравнения

(string1.equals(string2)) && !(string1 == string2)

EDIT

В ответ на комментарий: это не предназначалось для консультирования, а просто для прямого ответа на что мы не используем ключевое слово 'new' для строк, что просто неверно. Надеюсь, что это редактирование (в том числе и выше) немного разъясняет это. BTW - есть пара хороших и гораздо лучших ответов на вышеупомянутый вопрос о SO.

Строка подвержена нескольким оптимизациям (из-за отсутствия лучшей фразы). Обратите внимание, что String также имеет перегрузку оператора (для оператора +) - в отличие от других объектов. Так что это особый случай.

В Java строки являются особым случаем со многими правилами, которые применяются только к строкам. Двойные кавычки заставляют компилятор создавать объект String. Поскольку объекты String неизменяемы, это позволяет компилятору ставить несколько строк и создавать более большой пул строк. Две одинаковые строковые константы всегда будут иметь одну и ту же ссылку на объект. Если вы не хотите, чтобы это было так, вы можете использовать новую строку String (""), и это создаст объект String во время выполнения. Метод intern () обычно был общим, чтобы вызвать динамически создаваемые строки для проверки в таблице поиска строк. После того, как строка в интернированном, ссылка на объект укажет на канонический экземпляр String.

    String a = "foo";
    String b = "foo";
    System.out.println(a == b); // true
    String c = new String(a);
    System.out.println(a == c); // false
    c = c.intern();
    System.out.println(a == c); // true

Когда загрузчик классов загружает класс, все String-константы добавляются в пул строк.

Нет необходимости в новой строке, поскольку литерал (символы в кавычках) уже является объектом String, созданным при загрузке класса хоста. Совершенно законно ссылаться на методы на буквальном и донном, основное различие - удобство, предоставляемое литералами. Было бы большой болью и тратой времени, если бы нам пришлось создать массив символов и заполнить его char символом char, и они будут создавать новую строку (char array).

Поскольку String является неизменным классом в java.

Теперь почему это неизменное? Поскольку String является неизменным, поэтому он может быть разделен между несколькими потоками, и нам не нужно синхронизировать операцию String извне. Поскольку String также используется в режиме загрузки классов. Поэтому, если String изменен, тогда java.io.writer можно было бы изменить на abc.xyz.mywriter

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

Синтаксический сахар. Синтаксис

String s = new String("ABC");

все еще доступен.

Литеральный пул содержит любые строки, которые были созданы без использования ключевого слова new.

Существует разница: строка без новой ссылки сохраняется в строковом литеральном пуле, а String с новым говорит, что они в памяти кучи.

Строка с новыми находится в другом месте в памяти, как и любой другой объект.

TString obj1 = new TString("Jan Peter");                
TString obj2 = new TString("Jan Peter");                    

if (obj1.Name == obj2.Name)                 
    System.out.println("True");
else                
    System.out.println("False");

Выход:

True

Я создал два отдельных объекта, у обоих есть поле (ref) 'Name'. Так что даже в этом случае «Ян Питер» является общим, если я понимаю, как работают java.