As pointed out by Pete Kirkham, this is implementation specific. My answer is only correct for the Sun JRE, and only prior to Java 7 update 6.

You're right about a normal substring call just creating a new string referring to the same character array as the original string. That's what happens on line 5 too. The fact that the new string object reference happens to be assigned to a variable doesn't change the behaviour of the method.

Just to be clear, you say that in line 2 the new string will still point to "Monday" - the char array reference inside the string will be to the same char array as one used for "Monday". But "Monday" is a string in itself, not a char array. In other words, by the time line 2 has finished (and ignoring GC) there are two string objects, both referring to the same char array. One has a count of 6 and the other has a count of 3; both have an offset of 0.

You're wrong about line 4 using a "string pool" though - there's no pooling going on there. However, it is different to the other lines. When you call the String(String) constructor, the new string takes a copy of the character data of the original, so it's completely separate. This can be very useful if you only need a string which contains a small part of a very large original string; it allows the original large char array to be garbage collected (assuming nothing else needs it) while you hold onto the copy of the small portion. A good example of this in my own experience is reading lines from a line. By default, BufferedLineReader will read lines using an 80-character buffer, so every string returned will use a char array of at least 80 characters. If you're reading lots of very short lines (single words) the difference in terms of memory consumption just through the use of the odd-looking

line = new String(line);

can be very significant.

Does that help?

For example. In the following string we have 6 characters. So if you call .length() on the string it will return 6. Note that its indices will range from 0 to 5 (not to 6).

"A tree"

The indices would be like the following:

0 -> 'A'
1 -> ' '
2 -> 't'
3 -> 'r'
4 -> 'e'
5 -> 'e'

Using substring you can get a part of this string. Your result will be starting at the specifed begin index and will end at the specified end index.

Important:

The start index is inclusive, while the end index is exclusive.

Which means that if we use substring from 2 to 4, we won't get "tre". We will get "tr", since the end index is not included.

Programmers often use excluded end indices, since it is easier to work with them. For example. Imagine our string "A tree" is called s like this:

String s = "A tree";

if you would want everything starting at index 2 you could do:

String result = s.substring(2, s.length()); // Result would also be 'tree' for this example

If the end index wouldn't be exclusive you would need to write:

String result = s.substring(2, s.length() - 1); // This is an example that would return "tree", IF and only if end indices wouldn't be excluded

That is why programmers often exclude the end index.

Of corse if you want to start at a certain index and want to go till the end you don't need to use

String result = s.substring(2, s.length()); // Result would also be 'tree' for this example

but instead you could use the alternative version of substring, where you only provide a begin index and not an end index. Like this:

String result = s.substring(2); // Result would also be 'tree' for this example

Please take a look at the documentation for

1. substring(int, int) -> https://docs.oracle.com/javase/9/docs/api/java/lang/String.html#substring-int-int-
2. substring(int) -> https://docs.oracle.com/javase/9/docs/api/java/lang/String.html#substring-int-

substring method throws the StringIndexOutOfBoundsException only when the beginIndex is greater than the length of the string as shown in the below code (taken from String class substring method):

int subLen = value.length - beginIndex;
if (subLen < 0) {
    throw new StringIndexOutOfBoundsException(subLen);
}

Also, the same has been explained in the Javadoc as well, you can look here:

Returns a new string that is a substring of this string. The substring begins with the character at the specified index and extends to the end of this string. Examples:

"unhappy".substring(2) returns "happy"

"Harbison".substring(3) returns "bison"

"emptiness".substring(9) returns "" (an empty string)