Quantos objetos serão criados [Resolvido]

[quote=charlesbraw]Galera,
sei que exite milhões de tópicos abertos sobre quantos objetos são criados na concatenação de String, porém, fiquei com uma dúvida ao ver um simulado, para não ressuscitar nem um tópico resolvi criar esse:

veja o seguinte código:

public String makinStrings() {
			   String s = "Fred"; //aqui cria 2 ?
			   s = s + "47";  //aqui cria +1 ?
			   s = s.substring(2, 5); // aqui não seria +1 e o mesmo estaria para o GC?
			   s = s.toUpperCase(); // aqui não seria +1 e o mesmo estaria para o GC?
			   return s.toString();
	  }

Quantos objetos serão criados nesse código?
A resposta é 3,
mas fiquei confuso pois achava que ao fazer s.substring ou s.toUpperCase ele criava esses objetos e os mesmos ficariam para o GC.

resumindo…
achei que ao fazer isso

Esse exercicio ja foi discutido aqui varias vezes, o que acontece é que esse exercicio foi mau formulado, partindo do pré suposto que “Fred” e “47” ja existem no pool de Strings (Fato que o exercicio nao menciona), seriam 3 objetos mesmo.

Agora o que acontece quando vc executa sua classe sem existirem esses dois objetos citados no pool seria:

public String makinStrings() { String s = "Fred"; //Um objeto criado no pool de strings - 1 objeto no total. s = s + "47"; //Um objeto criado no pool de strings que é o objeto "47" e outro criado e atribuido á s "Fred47" - 3 no total. s = s.substring(2, 5); // Outro objeto criado pelo retorno do método substring - 4 no total. s = s.toUpperCase(); // E mais um criado pelo retorno do metodo toUpperCase - 5 no total. return s.toString(); }

evertonsilvagomesjava:

public String makinStrings() { String s = "Fred"; //Um objeto criado no pool de strings - 1 objeto no total. s = s + "47"; //Um objeto criado no pool de strings que é o objeto "47" e outro criado e atribuido á s "Fred47" - 3 no total. s = s.substring(2, 5); // Outro objeto criado pelo retorno do método substring - 4 no total. s = s.toUpperCase(); // E mais um criado pelo retorno do metodo toUpperCase - 5 no total. return s.toString(); }

Então everton, entendi o que você disse, agora se pergunta fosse quantos estão disponiveis para o GC eu diria 4? ou seja criaram os 5 porém apenas 1 tem referência.
seria isso mesmo? Já li esse assunto várias vezes, quando penso que entendi eu acabo me confundindo.

Isso mesmo.

Blza então everton, valeu.

Na minha consepção não, o GC só atua no Heap, e não no pool.
Outra coisa, ao tentar executar esse código, os objetos “Fred” e “47” sempre serão criados primeiro.
Literais String são criandos quando a classe é carregada. Não que a pergunta seja mal elaborada
só que ela quer saber quantos objetos são criados quando a jvm funfar !

A questão pergunta quantos objetos são gerados quando a jvm executar esse trecho de código.

public String makinStrings() {       
 String s = "Fred"; // Esse objeto "Fred" é criado quando a classe é carregada, e não quando a jvm passar por aqui.
     s = s + "47";  // O objeto "47" é criando quando a classe é carregada. O objeto "Fred47" só é criado quando a jvm passar por aqui.
     s = s.substring(2, 5); // objeto criando quanda a jvm passar por aqui.
     s = s.toUpperCase(); // objeto criando quanda a jvm passar por aqui. 
     return s.toString(); // Aqui ele passa por cópia.      
 }

Objetos criados quando a classe é carregada: 2 (“Fred”, “47”).
Objetos criados quando a jvm executa esse método: 3 (“fred47”, “ed4”, “ED4”).
Objetos perdidos: 4 (“fred”, “47”, “fred47”, “ed4”).
Referências ativas: 1 (ED4)
Objetos elegíveis para a coleta de lixo na minha consepção: 0

Pelo fato de o gc só atuar no heap. Acredito que fufa assim…

Atua nos dois.

Evertom donde você leu isso, existe um link aqui no forum ?

O GC elimina todos objetos do pool assim que a classe é descarregada pela JVM. Mas isso é questao da criaçao da VM. Porém nao quer dizer que mesmo antes do final da execução do aplicativo eles nao estao elegiveis, como neste caso estão.

Elegiveis != Apagados.

http://faq.javaranch.com/view?ScjpFaq#stringLiteralGC

Tem um topico ai criado tb pelo usuario Dota, logo abaixo desse, onde o Vini responde exatamente a mesma coisa :D.

Outra coisa, ao tentar executar esse código, os objetos “Fred” e “47” sempre serão criados primeiro.
Literais String são criandos quando a classe é carregada. Não que a pergunta seja mal elaborada

Não é questao de serem ou nao criados primeiro, é questão de estarem ou nao no pool.