Строковый пустой конструктор в java

Ответ 1

Ofcourse.....

String s = new String();

создаст объект Non-literal String в куче, в котором будет собран мусор.

где as

String s = "" ;

создаст строковый литерал. Этот не будет мусор, собранный когда-либо, если он доступен через загрузчик по умолчанию.

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

Является ли String Literal Pool набор ссылок на объект String или набор объектов

Ответ 2

Он создает пустую строку, которая, как представляется, имеет ограниченное использование.

Если вы создадите String путем конкатенации и не используете, например. StringBuiler, ваш код может начинаться как одно из следующих.

String result = new String();
String result = "";
String result = "first part of string";

// ...
result += "append to the result";

Первые два не эквивалентны, и вы должны предпочесть инициализировать с помощью "", так как это может использовать string интернирование.

Ответ 3

Маленький пример... Строка может быть собрана с мусором

System.out.println(1 + new String() + 2);

вместо

System.out.println(1 + "" + 2);

Ответ 4

В соответствии с документацией этот конструктор создает пустую последовательность.

public String()

Initializes a newly created String object so that it represents an empty character sequence. Note that use of this constructor is unnecessary since Strings are immutable.

Если вам нужна пустая последовательность, это имеет смысл.

Но обычно вам не нужно будет использовать пустой конструктор, прежде чем вносить в него изменения, так как вы не меняете String. Фактически, когда вы меняете, используя оператор + =, например, вы создаете еще одну неизменяемую строку и не меняете ее.

Проверьте этот вопрос по этому вопросу: Как работают объекты String (например, неизменяемые объекты)?

Ответ 5

Некоторая предыстория фона

Поскольку строки в Java неизменяемы, они также "интернированы" - это означает, что все строковые литералы в загруженных классах хранятся в пуле, поэтому обычно в одном экземпляре имеется только один экземпляр каждого уникального строкового литерала в одном время. Это приложение flyweight pattern, аналогичные пулы также хранятся для объектов Integer и других примитивных оболочек (но только для ограниченного числа небольших значений).

Из-за этого механизма сравнение идентичности строковых литералов (даже из разных классов) обычно возможно (хотя вы всегда должны использовать метод equals при сравнении строк для обеспечения безопасности и согласованности):

System.out.println("hello" == "hello"); // true

Теперь, если вы используете конструктор строк по умолчанию, вы получаете экземпляр пустой строки, но это экземпляр new, как указано в JavaDoc:

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

Такой новый экземпляр отличается от интернированной пустой строки, в результате чего:

System.out.println(new String() == ""); // false

Но, как я сказал, только строковые литералы автоматически интернированы - это означает, что строки, созданные вручную StringBuilders, из массивов char и т.д. не интернированы. Вы можете использовать метод String.intern(), чтобы поместить такую ​​строку в пул вручную.

Теперь для некоторого реального сценария

Ну, все это хорошо, но я все еще не ответил , почему этот конструктор существует. Ну, строки Java - это просто умные обертки над массивами char, а некоторые строковые объекты могут совместно использовать свои внутренние массивы.

Если я создаю очень длинную строку (например, чтение из потока), то этот экземпляр не интернирован (как сказано выше), поэтому он будет мусором, собранным после того, как переменная, на которую ссылается, выйдет из области видимости. Но если это сделать:

String longString = readVeryLongString();
String shortString = longString.subString(0, 10);

... тогда новый shortString не скопирует первые 10 символов из longString и поместит их в свой собственный новый массив char. Нет, он будет ссылаться на исходный массив, используя только первые 10 символов.

Теперь, если переменная shortString имеет более длительный срок службы (например, помещается в некоторый статический контекст), то базовый массив char не будет собираться с мусором (даже если исходный longString переменная уже вышла из сферы действия). Это один из способов создания утечки памяти в Java.

Теперь конструктор строк по умолчанию приходит на помощь! Если я изменил код выше на это:

String longString = readVeryLongString();
String shortString = new String(longString.subString(0, 10));

... тогда shortString будет новым экземпляром строки, который создал новый внутренний массив char, скопировав только 10 требуемых символов из исходной строки, возвращаемой методом subString.

Хорошая статья, иллюстрирующая эту тему:

http://illya-keeplearning.blogspot.cz/2009/03/java-string-internals.html

Ответ 6

чтобы создать пустую строку, вызовите конструктор по умолчанию как   String s new String();

создаст экземпляр String без символов в нем.