Dúvida na Quantidade de Strings Criadas [resolvido]

Given:   
 11. public String makinStrings() {   
 12.     String s = "Fred";  // 1. Puxo a string "Fred" do pool 
 13.     s = s + "47";        // 2. Crio um objeto StringBuilder, inicializo-o com o valor "Fred", adiciono a string "47" que está no pool, e então chamo o método toString() do StringBuilder, que cria a primeira string ("Fred47")
 14.     s = s.substring(2, 5); // 3. Crio a string "ed4"
 15.     s = s.toUpperCase(); // 4. Aqui a pegadinha. Se a string original fosse "FRED" então não seria criada uma nova string aqui. Mas como foi alterada, então é criada a string "ED4".
 16.     return s.toString();    // 5. O método toString da classe String retorna a própria string ("return this"). 
 17. }

Portanto, são criadas 3 strings.

Quando você diz:

String s = “Fred”; // 1. Puxo a string “Fred” do pool

Não criaremos uma nova String também?
Onde esta a contagem para chegar em 3? Não entendi.
Abraços.

Outra sutileza da linguagem.

Quando você faz isto aqui:

String s = "Fred";

está fazendo o seguinte:
a) O Java, ao carregar a sua classe (ou seja, antes de executar o método “makinStrings”), vê que existe uma literal “Fred” no código, e então cria uma string “Fred” e a insere no pool de strings
b) Quando você executar o método “makinStrings”, você vai simplesmente atribuir à variável s uma referência para a string “Fred”, que já está criada e está no pool de strings.

Então, para efeitos dessa questão, esse comando não conta como criação de strings.
b)

thingol:

Given: 11. public String makinStrings() { 12. String s = "Fred"; // 1. Puxo a string "Fred" do pool 13. s = s + "47"; // 2. Crio um objeto StringBuilder, inicializo-o com o valor "Fred", adiciono a string "47" que está no pool, e então chamo o método toString() do StringBuilder, que cria a primeira string ("Fred47") 14. s = s.substring(2, 5); // 3. Crio a string "ed4" 15. s = s.toUpperCase(); // 4. Aqui a pegadinha. Se a string original fosse "FRED" então não seria criada uma nova string aqui. Mas como foi alterada, então é criada a string "ED4". 16. return s.toString(); // 5. O método toString da classe String retorna a própria string ("return this"). 17. }
Portanto, são criadas 3 strings.

Tá bom - nas linhas 13 (“Fred47”), 14 (“ed4”) e 15 (“ED4”).

po cara … entendi … valew

pelo que vi … no exemplo do livro ele tava contando quantas string foram criadas até o momento …

e no testKiller … tava perguntando quantas strings seriam criadas durante a execução daquele método em especifico

por issu que eu me confundi XD

brigadão ae

thingol:

Given: 11. public String makinStrings() { 12. String s = "Fred"; // 1. Puxo a string "Fred" do pool 13. s = s + "47"; // 2. Crio um objeto StringBuilder, inicializo-o com o valor "Fred", adiciono a string "47" que está no pool, e então chamo o método toString() do StringBuilder, que cria a primeira string ("Fred47") 14. s = s.substring(2, 5); // 3. Crio a string "ed4" 15. s = s.toUpperCase(); // 4. Aqui a pegadinha. Se a string original fosse "FRED" então não seria criada uma nova string aqui. Mas como foi alterada, então é criada a string "ED4". 16. return s.toString(); // 5. O método toString da classe String retorna a própria string ("return this"). 17. }
Portanto, são criadas 3 strings.

Só não entendi um ponto: você está supondo que Fred já foi criado antes ou está faltando um pedaço do código onde ele é realmente criado?

então … pelo o que eu entendi … antes mesmo da aplicação propriamente dita ser executada

a JVM caça as string literais e cria um objeto para cada uma …ai
na hroa que realmente começa a rodar o programa … a JVM soh vai atribuindo o q ela criou às variaveis de referencia.

XD

javando:

então … pelo o que eu entendi … antes mesmo da aplicação propriamente dita ser executada

a JVM caça as string literais e cria um objeto para cada uma …ai
na hroa que realmente começa a rodar o programa … a JVM soh vai atribuindo o q ela criou às variaveis de referencia.

XD

Embora eu nunca tenha lido nada parecido com isso, essa foi a explicação que mais fez sentido pra mim. Também explicou porque o 47 não era uma nova String. Valeu!

thingol:

13. s = s + "47"; // 2. Crio um objeto StringBuilder, inicializo-o com o valor "Fred", adiciono a string "47" que está no pool, e então chamo o método toString() do StringBuilder, que cria a primeira string ("Fred47")

Cara, ta aí uma coisa que eu não sabia, o compilador cria um StringBuilder?!? Quer dizer que se eu fizer:

String r = "um";
String s = r + "dois";
String t = r + s;
String u = t + "tres" + r;

Acontecerá:

String r = <pega do pool "um">; // 0 Objetos
String s = new StringBuilder(r).append( <pega do pool "dois"> ).toString(); // 1° Objeto, no toString();
String t = new StringBuilder(r).append(s).toString(); // 2° Objeto, no toString()
String u = new StringBuilder(t).append( <pega do pool "tres"> ).append(r); // 3° Objeto, no toString();

É isso?!? Ou eu entendi tudo errado?

Trevisani:

thingol:

13. s = s + "47"; // 2. Crio um objeto StringBuilder, inicializo-o com o valor "Fred", adiciono a string "47" que está no pool, e então chamo o método toString() do StringBuilder, que cria a primeira string ("Fred47")

Cara, ta aí uma coisa que eu não sabia, o compilador cria um StringBuilder?!? Quer dizer que se eu fizer:

String r = "um";
String s = r + "dois";
String t = r + s;
String u = t + "tres" + r;

Acontecerá:

String r = <pega do pool "um">; // 0 Objetos
String s = new StringBuilder(r).append( <pega do pool "dois"> ).toString(); // 1° Objeto, no toString();
String t = new StringBuilder(r).append(s).toString(); // 2° Objeto, no toString()
String u = new StringBuilder(t).append( <pega do pool "tres"> ).append(r); // 3° Objeto, no toString();

É isso?!? Ou eu entendi tudo errado?

bom … eu acho q não é iso não cara rsrs

o amigo lah se confundiu na hora de escrever eu acho rsrs

Pois é, sei lá, por isso que eu fiquei meio assim… mas se estiver certo, então preciso estudar mais o.O

Trevisani:

thingol:

13. s = s + "47"; // 2. Crio um objeto StringBuilder, inicializo-o com o valor "Fred", adiciono a string "47" que está no pool, e então chamo o método toString() do StringBuilder, que cria a primeira string ("Fred47")

Cara, ta aí uma coisa que eu não sabia, o compilador cria um StringBuilder?!? Quer dizer que se eu fizer:

String r = "um";
String s = r + "dois";
String t = r + s;
String u = t + "tres" + r;

Acontecerá:

String r = <pega do pool "um">; // 0 Objetos
String s = new StringBuilder(r).append( <pega do pool "dois"> ).toString(); // 1° Objeto, no toString();
String t = new StringBuilder(r).append(s).toString(); // 2° Objeto, no toString()
String u = new StringBuilder(t).append( <pega do pool "tres"> ).append(r); // 3° Objeto, no toString();

É isso?!? Ou eu entendi tudo errado?

Você entendeu direitinho.