Apenas sendo criada uma instancia de valor "java" no pool...nenhum objeto criado na heap:

Uma string "java" criada no pool e um objeto String na heap:

Exemplo citado no livro K&B - SCJP Sun Certified Programmer for Java 5 Study Guide wrote:
String s = "abc"; // creates one String object and one reference variable
In this simple case, "abc" will go in the pool and s will refer to it.

String s = new String("abc"); // creates two objects, and one reference variable
In this case, because we used the new keyword, Java will create a new String object in normal (non-pool) memory,
and s will refer to it. In addition, the literal "abc" will be placed in the pool.

jbjares wrote:Caro brrodo,

Apenas sendo criada uma instancia de valor "java" no pool...nenhum objeto criado na heap:

String str = "java";

Até então pensava que com o literal um novo objeto fosse criado no heap e no pool. É isso mesmo?

jbjares wrote:

brrodo wrote:

Uma string "java" criada no pool e um objeto String na heap:

String str = new String("java");

No exemplo acima pensava estar sendo criadas dois objetos string no heap onde o literal iria para o pool.

jbjares wrote:
E em relação ao Garage Collector. Como poderei saber quantos objetos String estarão elegiveis ao coletor caso exista a repetição de strings (a reutilização de uma string do pool) se não se pode prever a forma de limpeza deste pool? Ainda não ficou claro para mim.

taaqui wrote:

Se estiver errado me corrijam.

taaqui wrote:Acho que não, se fosse assim eu faria

public class Testador { public static void main(String[] args) { String s1 = new String ("abacaxi"); String s4 = "abacaxi"; System.out.println (s1 == s4); } }

e teria que dar true por esta referenciando o mesmo id no pool de strings?

String s = new String("abc"); // creates two objects, and one reference variable
In this case, because we used the new keyword, Java will create a new String object in normal (non-pool) memory,
and s will refer to it. In addition, the literal "abc" will be placed in the pool.

Creating New Strings
Let's look at a couple of examples of how a String
might be created, and let's further assume that no other String objects exist in the
pool:
String s = "abc"; // creates one String object -- (A)
// and one reference variable
In this simple case, "abc" will go in the pool and s will refer to it. -- (B)
String s = new String("abc"); // creates two objects, -- (C)
// and one reference variable
In this case, because we used the new keyword, Java will create a new String object
in normal (nonpool) memory, and s will refer to it. -- (D)
In addition, the literal "abc" will -- (E)
be placed in the pool.

jbjares wrote:AUhuaUHAUhaUHUA Esses gráficos são bem legais mesmo taaqui...

Cara,

Vamos pegar a explicação da K.Sierra a respeito da criação de String. Comentarei os pontos críticos com (A,B,C,D...) para analisarmos melhor um a um.

Creating New Strings
Let's look at a couple of examples of how a String
might be created, and let's further assume that no other String objects exist in the
pool:
String s = "abc"; // creates one String object -- (A)
// and one reference variable
In this simple case, "abc" will go in the pool and s will refer to it. -- (B)
String s = new String("abc"); // creates two objects, -- (C)
// and one reference variable
In this case, because we used the new keyword, Java will create a new String object
in normal (nonpool) memory, and s will refer to it. -- (D)
In addition, the literal "abc" will -- (E)
be placed in the pool.

A) Um novo Objeto String é criado.
B) "abc" vai para o pool e "s" o referenciará. Então podemos pensar no pool de String como sendo um pool de objetos String e não em um pool de literais, Certo?
C) São criados dois Objetos String.
D) Por utilizar a palavra-chave new será criado um Objeto String no Heap e "s" o referenciará.
E) Adicionalmente o literal "abc" será inserido no pool. Neste ponto a coisa se complica. A lógica do tópico B) é exterminada quando ela diz que o literal "abc" vai para o pool, concorda? Então de que é composto esse pool, de Objetos ou literais? Caso ele seja composto por literais oque acontece com o Objeto criado no tópico A)? O lugar dos novos objetos não é o Heap? Então no tópico A) é criado um novo Objeto String que vai para o Heap e um literal que vai para o pool, mas a variável referencia o literal do pool no lugar do Objeto que foi para o Heap?

Está lançado o desafio. Vamos desmistificar de uma vez por todas aqui no GUJ o que de fato acontece no momento da criação de Strings!!!