Quantos objetos String são criados quando se invoca este metodo??
public String makinStrings() {
String s = ?Fred?;
s = s + "47";
s = s.substring(2, 5);
s = s.toUpperCase();
return s.toString();
}
Achei que fosse banana, contei 5…
“Fred” “47” “Fred47” + as 2 alterações… = 5
Segundo o gabarito a resposta é 3 !!!
valeu… pqp que sacanagem esta…
Puts…
eu tb colocaria 5 objetos criados!! :twisted:
Valeu ai thingol, excelente explicação, tá favoritado!!!
Então toda a vez que encontrar o seguinte código:
A JVM irá varrer o método e inseriá a string mala no pool de Strings e não será criado nehum objeto, é isso mesmo?
Agora se eu fizer:
Apesar do new, também não será criado nehum objeto, e a JVM irá inserir a string mala no pool se esta já não existir.
Entendi mesmo???
Uma outra dúvida surgiu agora.
String s = "Fred";
s = s + "47";
Além de criar um novo objeto, a String Fred47 será inserida no pool de strings???
E se logo a seguir ou em outro método eu tiver
String k = "Fred";
k = k + "47";E neste caso, a JVM irá criar um novo objeto string, ou primeiro irá no pool para verificar se já não existe uma string Fred47 e apontar para ela???
Grato.
[quote=rmalati]Uma outra dúvida surgiu agora.
String s = "Fred";
s = s + "47";
Além de criar um novo objeto, a String Fred47 será inserida no pool de strings??? [/quote]
Não; durante o tempo de execução, só conseguimos inserir uma string no pool usando o método “intern”. Por exemplo:
String s = Integer.toString (51966, 16); // deve gerar a string "cafe"
String t = s.intern(); // t recebe uma instância da string "cafe" que foi posta no pool.
// Note que s.intern() não é que põe a string s no pool;
// ela faz uma cópia da string s, e põe essa cópia no pool.
// Se a string "cafe" já existir no pool, retorna a cópia do pool.[quote]
E se logo a seguir ou em outro método eu tiver
String k = "Fred";
k = k + "47";E neste caso, a JVM irá criar um novo objeto string, ou primeiro irá no pool para verificar se já não existe uma string Fred47 e apontar para ela???
Grato.[/quote]
A JVM, por razões de desempenho, nunca fica procurando primeiro as coisas no pool.
Ela só procura no pool se você usar o método “intern”.
thingol, o seguinte código:
String s1 = "spring";
String s2 = s1 + "summer";
s1.concat("fall");
s2.concat(s1);
s1 += "winter";
System.out.println(s1 + " " +s2);Irá imprimir “spring winter spring summer”
No livro da Kathy, neste trecho de código diz que foram criados 8 objetos String:
1-“spring”, 2- “summer”(perdido), 3-“spring summer”, 4-“fall”(perdido), 5-“spring fall”(perdido), 6-“spring summer spring”(perdido), 7-“winter”(perdido), 8-“spring winter” (nesse ponto “spring foi perdido”). mas apenas 2 continuam com referências válidas.
Este código, estaria errado? Pois como vc disse(se entendi direito) o código String s1 = "spring"; não cria de fato um objeto já que a JVM irá inserir no pool, fazendo s1 apenas referenciar a String “spring”.
Confesso que relendo o seu post e agora tentando entender o livro, acabei ficando bem confuso.
Daria pra vc explicar o que de fato ocorre e quantos objetos são criados e em quais linhas???
Se puder dar uma luz, fico muito agradecido!
Grato.
Note que as seguintes strings foram criadas e estão no pool antes da execução deste método:
“spring”
“summer”
“fall”
" "
“winter”
String s1 = "spring"; // puxando a string "s1" do pool
String s2 = s1 + "summer"; // criando um StringBuilder, inicializando-o com s1,
//chamando o método append com o parâmetro "summer" (que vem do pool),
// e então chamando o método "toString" de StringBuilder. A 1a. string criada
// é "springsummer".
s1.concat("fall"); // criando o 2o. objeto String "springfall", que é perdido
s2.concat(s1); // criando o 3o. objeto String "springsummerspring", que é perdido
s1 += "winter"; // criando o 4o. objeto "springwinter", e deixando de referenciar
// o objeto "spring" do pool
System.out.println(s1 + " " +s2); // criando um StringBuilder, inicializando-o
// com s1, chamando o método append com o parâmetro " ", chamando
// o método append com o parâmetro s2, e então chamando o método
// "toString" de StringBuilder. A 5a. string criada é "springwinter springsummer"Então thingol, eu havia chegado também a 4 objetos criados.
Mas o livro diz 8 objetos.
Enfim na prova se aparecer uma questão desse tipo eu vou considerar o que você explicou.
Muito obrigado de novo. 
olá…
esse negocio de Strings e osso…
fiz uma classe e quero ver se entendi mesmo… ai thingol se puder dar uma olhada e me ajudar ai =)
package pct01;
public class Str {
void methodA(){
/*
* cria um obj string qnd a class e carregada pela VM
* e inseri esta no Pool...
* porem na hora da execuçao deste metodo
* não e criado nehum Obj... certo?
*/
String s = "Eu";
/*
* aqui mesma coisa... cria "Mesmo" e coloca no pool na hora do classload
* e cria um obj "Eu Mesmo" em tempo de execução
*/
s = s + "Mesmo";
/*
* então ele cria 2 obj na hora do classload
* e cria apenas 1 na hora da execução
* e isso? help!!!
*/
}
public static void main(String[] args) {
new Str().methodA();
}
}=)
então se perguntarem no exame… qnts obj são criados respondo 3…
agora se perguntarem qnts obj são criado na execução do metodoA respondo 1
seria isso?
Nossa bota osso nisso!!!
Eu entendi isso mesmo - 3 objetos criados: “Eu”, “Mesmo” e "Eu Mesmo"
mas apenas 1 objeto é criado pelo método: “Eu Mesmo”
É isso, ou surtei de vez??? :lol: