A. 1
B. 2
C. 3
D. 4
E. 5
F. 6

toString()
This object (which is already a string!) is itself returned.

substring(int beginIndex, int endIndex)
Returns a new string that is a substring of this string.

toUpperCase()
Converts all of the characters in this String to upper case using the rules of the default locale.

raphaelrabadan wrote:Já descobri uma explicação, pelo menos 90% dela. As strings literais são criadas em tempo de compilação ou é quando as classes são carregadas pela JVM. Ou seja, quando o método é invocado, "Fred" e "47" já estavam criados.
Sendo assim, tirando 2 da minha resposta, que era 5. Ficam 3.

bom, o toString não cria um novo objeto. Apenas retorna a referência para o próprio objeto:

na outra linha em: s = s + "47"; o compilador na verdade transforma o + em um stringbuffer e da um append...

Se não for necessária alteração voltará a mesma String, logo nenhum objeto é retornado.

No teste há alterações a serem feitas, logo irá retornar um novo objeto.

Mas isso não vem ao caso aqui. Só curiosidade.

luistiagos wrote:internamente por questões de performase ele deve fazer alguma especie de buffer... pois seria muita burrice uma criar um novo objeto s+"47" qdo se pode simplismente juntar os caracters... creio que internamente ele deva fazer algo semelhante a um stringbuffer por questoes de performace porem não sei como isto funciona... alguem sabe?

We'll finish this section by presenting an example of the kind of devilish String question you might expect to see on the exam. Take the time to work it out on paper (as a hint, try to keep track of how many objects and reference variables there are, and which ones refer to which).

String s1 = "spring ";
String s2 = s1 + "summer ";
s1.concat("fall ") ;
s2.concat(s1);
s1 += "winter ";
System.out.println(s1 + " " + s2);

What is the output? For extra credit, how many String objects and how many reference variables were created prior to the println statement?

Answer: The result of this code fragment is "spring winter spring summer". There are two reference variables, s1 and s2. There were a total of eight String objects created as follows: "spring", "summer " (lost), "spring summer", "fall" (lost), "spring fall" (lost), "spring summer spring" (lost), "winter" (lost), "spring winter" (at this point "spring" is lost). Only two of the eight String objects are not lost in this process.

Important Facts About Strings and Memory
In this section we'll discuss how Java handles String objects in memory, and some of the reasons behind these behaviors.

One of the key goals of any good programming language is to make efficient use of memory. As applications grow, it's very common for String literals to occupy large amounts of a program's memory, and there is often a lot of redundancy within the universe of String literals for a program. To make Java more memory efficient, the JVM sets aside a special area of memory called the "String constant pool." When the compiler encounters a String literal, it checks the pool to sec if an identical String already exists. If a match is found, the reference to the new literal is directed to the existing String, and no new String literal object is created. (The existing String simply has an additional reference.) Now we can start to see why making String objects immutable is such a good idea. If several reference variables refer to the same String without even knowing it, it would be very bad if any of them could change the String's value.

You might say, "Well that's all well and good, but what if someone overrides the String class functionality; couldn't that cause problems in the pool?" That's one of the main reasons that the String class is marked final. Nobody can override the behaviors of any of the String methods, so you can rest assured that the String objects you are counting on to be immutable will, in fact, be immutable.

internamente por questões de performase ele deve fazer alguma especie de buffer...