Dúvida na Quantidade de Strings Criadas [resolvido]

Programação Java
#1

Oia eu aqui de novo XD

tem outra questão do testKiller que me deixou com dúvida


Given: 
11. public String makinStrings() { 
12. String s = ?Fred?;  // 1   crio a String  "Fred"
13. s = s + ?47?;        // 2 crio a String  "47"   --- 3 concateno para criar a String  "Fred47"
14. s = s.substring(2, 5); // 4 crio a String q é um pedaço da outra, mas jogo ele fora
15. s = s.toUpperCase(); //5  crio outra String que tambem é jogada fora
16. return s.toString();    // 6 crio a String que será enviada como retorno do método
17. } 
How many String objects will be created when this method is invoked? 
A. 1 
B. 2 
C. 3 
D. 4 
E. 5 
F. 6

eu posso jurar que a resposta é a F … mas no ressult do testKliier tah a C

eu ate olhei de novo o livro dah Kathy, mas , ou minha interpretação da explicação tá muito errada … ou o testKileer tá errado.

opiniões?

Só para desencargo de conciencia:

funciona perfeitamente, portanto uma String literal também é um novo objeto String

XD
(porque q as áspas tão dando erro?)

#2 
 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.

#3

Quando você diz: [quote]String s = “Fred”; // 1. Puxo a string “Fred” do pool[/quote]
Não criaremos uma nova String também?
Onde esta a contagem para chegar em 3? Não entendi.
Abraços.

#4

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

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)

#5

[quote=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. [/quote]

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

#6

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

#7

[quote=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. [/quote]

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?

#8

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

#9

[quote=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[/quote]

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!

#10

[quote=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") [/quote]

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?

#11

[quote=Trevisani][quote=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") [/quote]

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?[/quote]

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

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

#12

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

#13

[quote=Trevisani][quote=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") [/quote]

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?[/quote]

Você entendeu direitinho.

#14