My friend sent me a question he saw in one mock exam for the Java certification about string objects:
String makeStrings(){
String s = "HI";
s = s + "5";
s = s.substring(0,1);
s = s.toLowerCase();
return s.toString();
}
How many string objects will be created when this method is invoked? The correct answer the exam gave was 3. But I think it's five.
Am I wrong?
String makeStrings() {
String s = "HI"; //String literal
s = s + "5"; //concatenation creates new String object (1)
s = s.substring(0,1); //creates new String object (2)
s = s.toLowerCase(); //creates new String object (3)
return s.toString(); //returns already defined String
}
With respect to the concatenation, when creating a new String,JVM uses StringBuilder, ie:
s = new StringBuilder(s).append("5").toString();
toString() for a StringBuilder is:
public String toString() {
return new String(value, 0, count); //so a new String is created
}
substring creates a new String object unless the entire String is indexed:
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex - beginIndex)
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}
toString() does NOT create a new String:
public String toString()
{
return this;
}
toLowerCase() is a pretty long method, but suffice it to say that if the String is not already in all lowercase, it will return a new String.
Given that the provided answer is 3, as Jon Skeet suggested, we can assume that both of the String literals are already in the String pool. For more information about when Strings are added to the pool, see Questions about Java's String pool.
substring will create an object here. It returns the same string only when your indices are at boundaries of original string - [0, s.length() - 1] –
Suburban toString() on a String. I made the necessary changes (for both). Thank you. –
Slope 3, one can deduce that the string literal was already added to the String pool. –
Slope 3, we CAN assume that the String was already in the pool--it's the only way the answer makes sense. –
Slope s = s + "5";
Is translated to:
String s = new StringBuilder(s).append("5").toString();
For now, one Object is created.
s = s.substring(0,1);
Creates a new String.
s = s.toLowerCase();
Creates a new Object.
return s.toString();
Doesn't create a String, it returns an already created one.
toString() { return this} –
Kerrill Some of the other answers do make sense, but what about the string literal?
String s = "HI";
For the string literals, when a .java file is compiled into a .class file, any string literals are noted in a special way, just as all constants are. When a class is loaded (note that loading happens prior to initialization), the JVM goes through the code for the class and looks for string literals.
When it finds one, it checks to see if an equivalent String is already referenced from the heap. If not, it creates a String instance on the heap and stores a reference to that object in the constant table
Once a reference is made to that string object, any references to that string literal throughout your program are simply replaced with the reference to the object referenced from the string literal pool.
Hence there should be four Java objects, although when the same method is called again and again then there would only be three objects as in the application the string literal pool contains the literal "HI".
Also, for more information on why new objects are created when the above method blocks are exectued we can also check the hash codes which are different for different strings (String being immutable.)
public static void main(String[] args)
{
NumberOfString str = new NumberOfString();
String s = str.makeStrings();
System.out.println(s.hashCode());
}
public String makeStrings()
{
String s = "HI";
System.out.println(s.hashCode());
s = s + "5";
System.out.println(s.hashCode());
s = s.substring(0, 1);
System.out.println(s.hashCode());
s = s.toLowerCase();
System.out.println(s.hashCode());
return s.toString();
}
You get the following output:
2305
71508
72
104
104
Should we not count in the String literal object in the above example?
© 2022 - 2024 — McMap. All rights reserved.
new String()calls do. Unless you think it is desirable to have a separate question every time the preconditions or the numerical answer is different, e.g. 1,2,3,4,5,... ad infinitum I really cannot see the point of your comment. – Freightagesubstring(),toLowerCase() andtoString()` is what I meant. – Slopesubstring(),toLowerCase(), andtoString()which the other question does not include. I do not know why this was closed... – SlopeStringand thechar[](possibly abyte[]) that it wraps. – Everara