В чем разница между «текстом» и новой строкой («текст»)?

В чем разница между этими двумя утверждениями?

String s = "text";

String s = new String("text");

new String("text"); явно создает новый и референциально отличный экземпляр Stringобъекта; String s = "text";может повторно использовать экземпляр из пула строковых констант, если он доступен.

Вы очень редко бы хотели использовать new String(anotherString)конструктор. Из API:

String(String original): Инициализирует вновь созданный String объект, чтобы он представлял ту же последовательность символов, что и аргумент; другими словами, вновь созданная строка является копией строки аргумента. Если не требуется явная копия оригинала, использование этого конструктора не требуется, поскольку строки являются неизменяемыми.

Смежные вопросы

• Строки Java: «String s = new String (» глупо «);»
• Строки - это объекты в Java, так почему бы нам не использовать «new» для их создания?

Что означает ссылочное различие

Изучите следующий фрагмент:

    String s1 = "foobar";
    String s2 = "foobar";

    System.out.println(s1 == s2);      // true

    s2 = new String("foobar");
    System.out.println(s1 == s2);      // false
    System.out.println(s1.equals(s2)); // true

==на двух ссылочных типах есть сравнение ссылочной идентичности. Два объекта, equalsкоторые не обязательно ==. Обычно неправильно использовать ==ссылочные типы; большую часть времени equalsнужно использовать вместо этого.

Тем не менее, если по какой-либо причине вам нужно создать две строки, equalsно не ==строку, вы можете использовать new String(anotherString)конструктор. Однако нужно еще раз сказать, что это очень своеобразно и редко является намерением.

Ссылки

• JLS 15.21.3 Операторы справочного равенства == и! =
• class Object - boolean Object(equals)

Связанные вопросы

• Java String.equals против ==
• Как сравнить строки в Java?

Строковые литералы войдут в String Constant Pool .

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

Создание объекта построчно:

String str1 = new String("java5");

Используя строковый литерал "java5" в конструкторе, новое строковое значение сохраняется в пуле строковых констант. Используя оператор new, в куче создается новый строковый объект со значением «java5».

String str2 = "java5"

Ссылка "str2" указывает на уже сохраненное значение в пуле строковых констант

String str3 = new String(str2);

В куче создается новый строковый объект с тем же значением, что и у ссылки "str2"

String str4 = "java5";

Ссылка "str4" указывает на уже сохраненное значение в пуле строковых констант

Всего объектов: куча - 2, бассейн - 1

Дальнейшее чтение в сообществе Oracle

Создается строка в пуле строковых констант

String s = "text";

другой создает строку в константе pool ( "text"), а другую - в обычном пространстве кучи ( s). Обе строки будут иметь одинаковое значение «text».

String s = new String("text");

s затем теряется (имеет право на GC), если впоследствии не используется.

Строковые литералы, с другой стороны, используются повторно. Если вы используете "text"в нескольких местах вашего класса, на самом деле это будет одна и только одна строка (т.е. несколько ссылок на одну и ту же строку в пуле).

JLS

Концепция называется «интернирование» в JLS.

Соответствующий отрывок из JLS 7 3.10.5 :

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

Пример 3.10.5-1. Строковые литералы

Программа, состоящая из модуля компиляции (§7.3):

package testPackage;
class Test {
    public static void main(String[] args) {
        String hello = "Hello", lo = "lo";
        System.out.print((hello == "Hello") + " ");
        System.out.print((Other.hello == hello) + " ");
        System.out.print((other.Other.hello == hello) + " ");
        System.out.print((hello == ("Hel"+"lo")) + " ");
        System.out.print((hello == ("Hel"+lo)) + " ");
        System.out.println(hello == ("Hel"+lo).intern());
    }
}
class Other { static String hello = "Hello"; }

и блок компиляции:

package other;
public class Other { public static String hello = "Hello"; }

производит вывод:

true true true true false true

JVMs

JVMS 7 5.1 говорит :

Строковый литерал является ссылкой на экземпляр класса String и является производным от структуры CONSTANT_String_info (§4.4.3) в двоичном представлении класса или интерфейса. Структура CONSTANT_String_info дает последовательность кодовых точек Unicode, составляющих строковый литерал.

Язык программирования Java требует, чтобы идентичные строковые литералы (то есть литералы, которые содержат одинаковую последовательность кодовых точек) должны ссылаться на один и тот же экземпляр класса String (JLS §3.10.5). Кроме того, если метод String.intern вызывается для какой-либо строки, результатом является ссылка на тот же экземпляр класса, который будет возвращен, если эта строка появится в виде литерала. Таким образом, следующее выражение должно иметь значение true:

("a" + "b" + "c").intern() == "abc"

Для получения строкового литерала виртуальная машина Java проверяет последовательность кодовых точек, заданных структурой CONSTANT_String_info.

• Если метод String.intern ранее вызывался для экземпляра класса String, содержащего последовательность кодовых точек Unicode, идентичную той, которая задана структурой CONSTANT_String_info, то результатом строкового литерального вывода является ссылка на тот же экземпляр класса String.

• В противном случае создается новый экземпляр класса String, содержащий последовательность кодовых точек Unicode, заданную структурой CONSTANT_String_info; ссылка на этот экземпляр класса является результатом строкового литерала. Наконец, метод intern нового экземпляра String вызывается.

Bytecode

Также полезно взглянуть на реализацию байт-кода в OpenJDK 7.

Если мы декомпилируем:

public class StringPool {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        String c = new String("abc");
        System.out.println(a);
        System.out.println(b);
        System.out.println(a == c);
    }
}

у нас по постоянному пулу:

#2 = String             #32   // abc
[...]
#32 = Utf8               abc

и main:

 0: ldc           #2          // String abc
 2: astore_1
 3: ldc           #2          // String abc
 5: astore_2
 6: new           #3          // class java/lang/String
 9: dup
10: ldc           #2          // String abc
12: invokespecial #4          // Method java/lang/String."<init>":(Ljava/lang/String;)V
15: astore_3
16: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
19: aload_1
20: invokevirtual #6          // Method java/io/PrintStream.println:(Ljava/lang/String;)V
23: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
26: aload_2
27: invokevirtual #6          // Method java/io/PrintStream.println:(Ljava/lang/String;)V
30: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
33: aload_1
34: aload_3
35: if_acmpne     42
38: iconst_1
39: goto          43
42: iconst_0
43: invokevirtual #7          // Method java/io/PrintStream.println:(Z)V

Обратите внимание, как:

• 0и 3: ldc #2загружается одна и та же константа (литералы)
• 12: создается новый экземпляр строки (с #2аргументом as)
• 35: aи cсравниваются как обычные объекты сif_acmpne

Представление константных строк довольно волшебно в байт-коде:

• у него есть специальная структура CONSTANT_String_info , в отличие от обычных объектов (например new String)
• структура указывает на структуру CONSTANT_Utf8_info, которая содержит данные. Это единственные необходимые данные для представления строки.

и цитата JVMs выше , кажется, говорят , что всякий раз , когда utf8 указал на то же самое, то идентичные экземпляры загружаются ldc.

Я сделал аналогичные тесты для полей, и:

• static final String s = "abc"указывает на таблицу констант через атрибут ConstantValue
• не финальные поля не имеют этого атрибута, но все еще могут быть инициализированы с ldc

Вывод : есть прямая поддержка байт-кода для пула строк, и представление памяти эффективно.

Бонус: сравните это с целочисленным пулом , который не имеет прямой поддержки байт-кода (т.е. не имеет CONSTANT_String_infoаналогов).

@Braj: я думаю, что вы упомянули об обратном. Пожалуйста, поправьте меня, если я ошибаюсь

Создание объекта построчно:

String str1 = новая строка ("java5")

   Pool- "java5" (1 Object)

   Heap - str1 => "java5" (1 Object)

String str2 = "java5"

  pool- str2 => "java5" (1 Object)

  heap - str1 => "java5" (1 Object)

String str3 = новая строка (str2)

  pool- str2 => "java5" (1 Object)

  heap- str1 => "java5", str3 => "java5" (2 Objects)

String str4 = "java5"

  pool - str2 => str4 => "java5" (1 Object)

  heap - str1 => "java5", str3 => "java5" (2 Objects)

Думайте о "bla"том, чтобы быть волшебной фабрикой как Strings.createString("bla")(псевдо). Фабрика содержит пул всех строк, созданных таким образом.

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

Если нет, то он создает новый строковый объект внутри, сохраняет его в пуле и затем возвращает его. Таким образом, когда то же самое строковое значение запрашивается в следующий раз, оно возвращает тот же экземпляр.

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

Один простой способ понять разницу ниже:

String s ="abc";
String s1= "abc";
String s2=new String("abc");

        if(s==s1){
            System.out.println("s==s1 is true");
        }else{
            System.out.println("s==s1 is false");
        }
        if(s==s2){
            System.out.println("s==s2 is true");
        }else{
            System.out.println("s==s2 is false");
        }

вывод

s==s1 is true
s==s2 is false

Таким образом, new String () всегда будет создавать новый экземпляр.

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

String obj1 = "abc";
String obj2 = "abc";

«obj1» и «obj2» будут указывать на один и тот же строковый литерал, а пул строкового литерала будет иметь только один литерал «abc».

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

String obj1 = new String("abc");
String obj2 = new String("abc");

«obj1» и «obj2» будут указывать на два разных объекта в куче, а пул строкового литерала будет иметь только один литерал «abc».

Также следует отметить, что в отношении поведения строк следует отметить, что любое новое присваивание или конкатенация, выполняемая со строкой, создает новый объект в памяти.

String str1 = "abc";
String str2 = "abc" + "def";
str1 = "xyz";
str2 = str1 + "ghi";

Теперь в приведенном выше случае:
строка 1: литерал «abc» хранится в пуле строк.
Строка 2: литерал «abcdef» сохраняется в пуле строк.
Строка 3: новый литерал «xyz» сохраняется в пуле строк, и «str1» начинает указывать на этот литерал.
Строка 4: поскольку значение генерируется путем добавления к другой переменной, результат сохраняется в памяти кучи, а добавляемый литерал «ghi» будет проверен на наличие в пуле строк и будет создан, так как он не существует в вышеуказанный случай.

Хотя это выглядит одинаково с точки зрения программистов, оно оказывает большое влияние на производительность. Вы хотели бы использовать первую форму почти всегда.

String str = new String("hello")

Он проверит, содержит ли пул констант String строку "hello"? Если он присутствует, он не будет добавлять запись в пул констант String. Если нет, то он добавит запись в пул констант String.

Объект будет создан в области памяти кучи и str ссылки будут ссылаться на объект, созданный в области динамической памяти.

если вам нужна strссылка на точечный объект, содержащийся в пуле констант String, нужно явно вызватьstr.intern();

String str = "world";

Он проверит, содержит ли пул констант String строку "hello"? Если он присутствует, он не будет добавлять запись в пул констант String. Если нет, то он добавит запись в пул констант String.

В обоих вышеупомянутых случаях strссылки на String "world"присутствуют в пуле констант.

Когда вы храните строку как

String string1 = "Hello";

непосредственно, затем JVM создает объект String с заданной ценой в течение отдельного блока памяти, называемого постоянным пулом String.

И всякий раз, когда мы имеем тенденцию пытаться создать другую строку как

String string2 = "Hello";

JVM проверяет, существует ли какой-либо объект String с постоянной ценой в пуле констант String, если это так, вместо создания нового объекта JVM назначает ссылку на существующий объект новой переменной.

И когда мы храним String как

String string = new String("Hello");

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