Qual é a diferença entre "text" e new String ("text")?

Qual é a diferença entre essas duas afirmações a seguir?

String s = "text";

String s = new String("text");

new String("text"); cria explicitamente uma instância nova e referencialmente distinta de um Stringobjeto; String s = "text";pode reutilizar uma instância do pool constante de cadeias, se houver uma disponível.

Você raramente gostaria de usar o new String(anotherString)construtor. Na API:

String(String original): Inicializa um objeto recém-criado String para que ele represente a mesma sequência de caracteres que o argumento; em outras palavras, a sequência recém-criada é uma cópia da sequência de argumentos. A menos que uma cópia explícita do original seja necessária, o uso desse construtor é desnecessário, pois as strings são imutáveis.

Perguntas relacionadas

• Java Strings: "String s = new String (" bobo ");"
• Strings são objetos em Java, então por que não usamos 'new' para criá-los?

O que significa distinção referencial

Examine o seguinte trecho:

    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

==em dois tipos de referência é uma comparação de identidade de referência. Dois objetos que equalsnão são necessariamente ==. Geralmente, é errado usar ==em tipos de referência; a maior parte do tempo equalsprecisa ser usada.

No entanto, se por qualquer motivo você precisar criar duas, equalsmas não uma ==sequência, poderá usar o new String(anotherString)construtor. É preciso dizer novamente, porém, que isso é muito peculiar e raramente é a intenção.

Referências

• JLS 15.21.3 Operadores de igualdade de referência == e! =
• class Object - boolean Object(equals)

Assuntos relacionados

• Java String.equals versus ==
• Como eu comparo strings em Java?

Literais de seqüência de caracteres irão para o Pool de Constantes de String .

O instantâneo abaixo pode ajudá-lo a entendê-lo visualmente para lembrá-lo por mais tempo.

Criação de objeto linha por linha:

String str1 = new String("java5");

Usando a string literal "java5" no construtor, um novo valor da string é armazenado no pool constante da string. Usando o novo operador, um novo objeto de sequência é criado no heap com "java5" como valor.

String str2 = "java5"

A referência "str2" está apontada para o valor já armazenado no pool constante de strings

String str3 = new String(str2);

Um novo objeto de string é criado no heap com o mesmo valor da referência por "str2"

String str4 = "java5";

A referência "str4" está apontada para o valor já armazenado no pool constante de strings

Total de objetos: Pilha - 2, Piscina - 1

Leitura adicional na comunidade Oracle

Um cria uma string no pool constante de strings

String s = "text";

o outro cria uma sequência no pool constante ( "text") e outra no espaço de pilha normal ( s). Ambas as strings terão o mesmo valor, o de "text".

String s = new String("text");

s é então perdido (elegível para o GC) se não for usado posteriormente.

Literais de string, por outro lado, são reutilizados. Se você usar "text"em vários locais da sua classe, será de fato uma e apenas uma String (ou seja, várias referências à mesma string no pool).

JLS

O conceito é chamado de "interning" pelo JLS.

Passagem relevante da JLS 7 3.10.5 :

Além disso, um literal de string sempre se refere à mesma instância da classe String. Isso ocorre porque literais de strings - ou, de maneira mais geral, strings que são os valores de expressões constantes (§15.28) - são "internados" para compartilhar instâncias exclusivas, usando o método String.intern.

Exemplo 3.10.5-1. Literais de cordas

O programa que consiste na unidade de compilação (§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"; }

e a unidade de compilação:

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

produz a saída:

true true true true false true

JVMS

O JVMS 7 5.1 diz :

Um literal de string é uma referência a uma instância da classe String e é derivado de uma estrutura CONSTANT_String_info (§4.4.3) na representação binária de uma classe ou interface. A estrutura CONSTANT_String_info fornece a sequência de pontos de código Unicode que constituem a cadeia literal.

A linguagem de programação Java requer que literais de string idênticos (ou seja, literais que contenham a mesma sequência de pontos de código) se refiram à mesma instância da classe String (JLS §3.10.5). Além disso, se o método String.intern for chamado em qualquer string, o resultado será uma referência à mesma instância de classe que seria retornada se essa string aparecesse como um literal. Portanto, a seguinte expressão deve ter o valor true:

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

Para derivar um literal de cadeia, a Java Virtual Machine examina a sequência de pontos de código fornecidos pela estrutura CONSTANT_String_info.

• Se o método String.intern já foi chamado em uma instância da classe String que contém uma sequência de pontos de código Unicode idênticos àqueles fornecidos pela estrutura CONSTANT_String_info, o resultado da derivação literal da string é uma referência à mesma instância da classe String.

• Caso contrário, uma nova instância da classe String será criada contendo a sequência de pontos de código Unicode fornecidos pela estrutura CONSTANT_String_info; uma referência a essa instância de classe é o resultado da derivação literal de cadeia de caracteres. Por fim, o método interno da nova instância String é chamado.

Bytecode

Também é instrutivo examinar a implementação de bytecode no OpenJDK 7.

Se decompilarmos:

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);
    }
}

temos na piscina constante:

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

e 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

Observe como:

• 0e 3: a mesma ldc #2constante é carregada (os literais)
• 12: uma nova instância de string é criada (com #2como argumento)
• 35: ae csão comparados como objetos regulares comif_acmpne

A representação de strings constantes é bastante mágica no bytecode:

• possui uma estrutura CONSTANT_String_info dedicada , diferente de objetos regulares (por exemplo new String)
• o struct aponta para uma estrutura CONSTANT_Utf8_info que contém os dados. Esses são os únicos dados necessários para representar a sequência.

e a citação da JVMS acima parece dizer que sempre que o Utf8 apontado é o mesmo, instâncias idênticas são carregadas ldc.

Eu fiz testes semelhantes para campos e:

• static final String s = "abc"aponta para a tabela constante por meio do atributo ConstantValue
• campos não finais não possuem esse atributo, mas ainda podem ser inicializados com ldc

Conclusão : existe suporte direto de bytecode para o conjunto de strings e a representação de memória é eficiente.

Bônus: compare isso ao pool Inteiro , que não possui suporte direto ao bytecode (ou seja, sem CONSTANT_String_infoanalógico).

@ Braj: Eu acho que você mencionou o contrário. Por favor corrija-me se eu estiver errado

Criação de objeto linha por linha:

String str1 = new String ("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 = new String (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)

Pense em "bla"ser uma fábrica mágica como Strings.createString("bla")(pseudo). A fábrica possui um conjunto de todas as strings criadas dessa maneira.

Se for invocado, ele verifica se já existe uma sequência no pool com esse valor. Se verdadeiro, ele retorna esse objeto de string, portanto, as strings obtidas dessa maneira são realmente o mesmo objeto.

Caso contrário, ele cria um novo objeto de cadeia internamente, o salva no pool e o retorna. Portanto, quando o mesmo valor da string é consultado na próxima vez, ele retorna a mesma instância.

A criação manual new String("")substitui esse comportamento ignorando o pool literal de cadeias. Portanto, a igualdade deve sempre ser verificada usando o equals()que compara a sequência de caracteres em vez da igualdade de referência do objeto.

Uma maneira simples de entender a diferença está abaixo:

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");
        }

saída é

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

Assim, novo String () sempre criará uma nova instância.

Qualquer literal de String é criado dentro do pool literal de strings e o pool não permite duplicatas. Portanto, se dois ou mais objetos de string forem inicializados com o mesmo valor literal, todos os objetos apontarão para o mesmo literal.

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

"obj1" e "obj2" apontarão para a mesma string literal e o pool literal de strings terá apenas um literal "abc".

Quando criamos um objeto de classe String usando a nova palavra-chave, a string criada é armazenada na memória heap. Qualquer literal de cadeia passada como parâmetro para o construtor da classe String, no entanto, é armazenada no conjunto de cadeias. Se criarmos vários objetos usando o mesmo valor com o novo operador, um novo objeto será criado na pilha a cada vez, por causa desse novo operador deve ser evitado.

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

"obj1" e "obj2" apontarão para dois objetos diferentes no heap e o pool literal de cadeias terá apenas um literal "abc".

Também algo que vale a pena observar com relação ao comportamento das strings é que qualquer nova atribuição ou concatenação feita na string cria um novo objeto na memória.

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

Agora, no caso acima:
Linha 1: literal "abc" é armazenado no pool de cadeias.
Linha 2: o literal "abcdef" é armazenado no pool de strings.
Linha 3: Um novo literal "xyz" é armazenado no pool de strings e "str1" começa a apontar para esse literal.
Linha 4: Como o valor é gerado anexando a outra variável, o resultado é armazenado na memória heap e o literal que está sendo anexado "ghi" será verificado quanto à sua existência no pool de strings e será criado, uma vez que não existe no o caso acima.

Embora pareça o mesmo do ponto de vista dos programadores, ele tem um grande impacto no desempenho. Você deseja usar o primeiro formulário quase sempre.

String str = new String("hello")

Ele irá verificar se o pool constante de String já contém String "hello"? Se presente, ele não adicionará uma entrada no pool constante de String. Se não estiver presente, ele adicionará uma entrada no pool constante de String.

Um objeto será criado em uma área de memória de heap e strpontos de referência para o objeto criado no local da memória de heap.

se você deseja fazer strreferência ao objeto de ponto que contém no pool constante de String, é necessário chamar explicitamentestr.intern();

String str = "world";

Ele irá verificar se o pool constante de String já contém String "hello"? Se presente, ele não adicionará uma entrada no pool constante de String. Se não estiver presente, ele adicionará uma entrada no pool constante de String.

Nos dois casos acima, a strreferência aponta para String "world"presente no pool Constant.

Quando você armazena uma String como

String string1 = "Hello";

diretamente, a JVM cria um objeto String com o preço especificado durante um bloco de memória separado chamado pool constante de String.

E sempre que temos a tendência de tentar produzir outra String como

String string2 = "Hello";

A JVM verifica se existe algum objeto String com preço constante no conjunto de constantes String, se houver, em vez de criar um novo objeto, a JVM atribui a referência do objeto existente à nova variável.

E quando armazenamos String como

String string = new String("Hello");

usando a nova palavra-chave, um novo objeto com o preço especificado é criado, independentemente do conteúdo do pool constante de String.