Unless, of course, I don't understand what you mean by "pinning
mechanism" in the first place...
I have taken another look. You are right. I did not make this up.
Base strings are STILL pinned.
When I did a detailed look at this a long time ago, I discovered
substring worked NOT by copying a string a characters and creating a
new String object with its own internal char[]. Instead it just
pointed to the BASE string's char[] object, and recorded an offset and
length.
If you then did a short substring of a giant string, and dropped all
references to the giant string, the giant String (or at least its
char[] guts) were pinned in RAM by the internal reference of the new
substring.
You could break this pinning/encumbrance by doing a new String on the
substring, which force a copy, and frees ongoing dependence on the
base.
New String is smart enough to avoid the copy if the substring and the
full string are identical. There is no benefit in breaking the pin,
and a penalty of creating a duplicate.
the code in there TODAY for substring looks like this:
/**
* Returns a new string that is a substring of this string. The
* substring begins at the specified <code>beginIndex</code> and
* extends to the character at index <code>endIndex - 1</code>.
* Thus the length of the substring is
<code>endIndex-beginIndex</code>.
* <p>
* Examples:
* <blockquote><pre>
* "hamburger".substring(4, 8) returns "urge"
* "smiles".substring(1, 5) returns "mile"
* </pre></blockquote>
*
* @param beginIndex the beginning index, inclusive.
* @param endIndex the ending index, exclusive.
* @return the specified substring.
* @exception IndexOutOfBoundsException if the
* <code>beginIndex</code> is negative, or
* <code>endIndex</code> is larger than the length of
* this <code>String</code> object, or
* <code>beginIndex</code> is larger than
* <code>endIndex</code>.
*/
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);
}
There is no sign of the old pinning logic there.
Further one-parm substring is defined in terms of that with:
public String substring(int beginIndex) {
return substring(beginIndex, count);
}
Again so sign of the alleged pinning.
However, if you look at the hidden String constructor used internally,
you see:
// Package private constructor which shares value array for speed.
String(int offset, int count, char value[]) {
this.value = value;
this.offset = offset;
this.count = count;
}
there you are! creating the substring with a pin!!! Just as I
remembered. So things have not changed, perhaps just rearranged a
little. Substring DOES pin the base String's char[] array in RAM. The
pinning is done in the hidden String constuctor used by substring.
