Quantas String são Criadas?

String s = "Fred";
s = s + "47";
s = s.substring(2, 5);
s = s.toUpperCase();
return s.toString();

Linha 1 - s é uma referência para uma string do pool, portanto não está sendo criada nenhuma string aí
Linha 2 - criou-se uma nova string (“Fred47”). s = s + “47” é uma abreviação para:
StringBuffer sb = new StringBuffer (s); sb.append (47); s = sb.toString();
Linha 3 - criou-se uma nova string (“ed4”). Entretanto não se criou um novo char[] porque substring, dentro da medida do possível,
reaproveita o char[] da string anterior.
Linha 4 - criou-se uma nova string (“ED4”).
Linha 5 - toString, no caso de strings, retorna a string original, então não há uma criação de uma nova string.

O total é 3, não? (Se bem que isso é questão para Java 1.4, não para Java 5.0 que não fica repisando essas coisas babacas).

Edit - na linha 2 a string “47” também é uma string do pool, pois é uma constante. A resposta continua 3.

Thingol… Eu jurava que era 5 tipo … porque a propria String “Fred” não é uma String criada…? :roll:

e a outra String que criaria seria a quantos essa linha abaixo fosse executado…

s = s +"47";//cria uma String 47.... depois faz s referenciar Fred47...

Pensei que era assim… Parece que tá assim no Livro da K&B não ?

Eu colocaria 4…
Na primeira linha, não há a criação da String “Fred”, thingol? Não sabemos se ela está no buffer…

POr que 4 rodrigo …

Corrigindo: 5

Olha o que eu penso…

String s = "Fred";//cria um String Fred, não sabemos se já está no Poll... String s = s + "47"; //cria uma String 47.. e faz s referenciar para uma outra String Fred47.... String s = s.subString(2, 5); // cria uma subString ed4.. String s = s.toUpperCase();// cria uma outra String ED4.
Contando 5 String.

Ao meu ver são 4, não seriam?

Eu acho que esse tipo de questão é perda de tempo. Se vai cair alguma coisa dessas, só se for em uma prova de 1.4, não de 5.0.

(De fato, mesmo na prova da 5.0 caem perguntas do tipo “quantos objetos serão criados”, mas não supõem essas coisas de “strings constantes estão já no pool, portanto não serão criadas em tempo de execução”.
Elas são até um pouco mais chatas, mas não tão ingênuas quanto essa questão apresentada aí.)

5 é a resposta correta!

a resposta do Raff está certa.

Raff:

Ai pessoal para quem ta estudando para tirar a certificação quantas String são criadas no codigo abaixo…

String s = "Fred"
s = s + "47";
s = s.substring(2, 5);
s = s.toUpperCase();
return s.toString();

QUantos Objetos String são criados ao executar esse trecho de código…
a.1
b.2
c.3
d.4
e.5

5 strings é a resposta certa ao meu ver…

Strings criadas
"Fred"
"47"
"Fred47"
"ed4"
“ED4”

Foi o que eu Achei tbm

é o que marcaria tb 5, devido lembrar da regra q string sao imutaveis… e temos ali entao os apontamentos com = e entao quando fui contando e vendo as novas referencias chegui a 5.

linha 1 - tenho uma string
linha 2 - tenho 2 string com um novo valor
linha 3 - tenho uma nova string alterada
linha 4 - mais uma string em maiusculo…
a linha 5 é um retorno… para para o metodo…(q ele ou a questao nao colocou, por nao ser importante)

eu olhei essa questao assim… mais essas questoes são chatas demais… teve 1 dessa so na minha prova… :(.

fiz todos os simulados do whizlabs e nao tinha nenhuma questão dessa natureza…

tomara que nao caia mesmo na prova… questao chata … :roll:

Chata é apelido na boa não sei na onde isso vai me auxiliar no futuro hauhauha

Onde é que você pegou essa questão?
Lembre-se: para resolver corretamente essa questão, você precisaria de conhecer o pool de strings, mas isso não faz parte do currículo da prova, portanto não deve cair desse jeito.

parece questao do livro da kathy.

Ai galera eu peguei do site JavaRanch !!!

Já que você pegou do JavaRanch, aqui tem a resposta do JavaRanch:

http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=24&t=039252

Veja a resposta do sr. Raghavan Muthu. (Eu sei que Raghavan é nome de homem porque há um Raghavan Srinivas na Sun que dá palestras quase todo ano aqui no Brasil, no Sun Tech Days.)

thingol vc está certo, são tres!

Analisando a referencia do Java Ranch:

• as literais de String são criadas durante o class-loading e não quando o método é chamado;
• o método toString retorna o mesmo objeto, não cria outro.

essa questão realmente é difícil.