RFR: 8305774: String.join(CharSequence, Iterable) can be optimized if Iterable is a Collection [v2]
Glavo
duke at openjdk.org
Mon Apr 10 04:59:43 UTC 2023
On Sun, 9 Apr 2023 02:28:37 GMT, Tingjun Yuan <duke at openjdk.org> wrote:
>> In the current implementation of `String.join(CharSequence, Iterable)`, the temp array `elems` is always initialized with a length of 8. It will cause many array recreations when the `Iterable` contains more than 8 elements. Furthermore, it's very common that an `Iterable` is also a `Collection`. So if the `Iterable` is an instance of `Collection`, the initial length of the array can be `((Collection<?>)elements).size()`. It will not change the current behavior even if the `Collection` is modified asynchronously.
>>
>> I don't know whether this change requires a CSR request.
>
> Tingjun Yuan has updated the pull request incrementally with one additional commit since the last revision:
>
> Add benchmark
If you really don't trust a collection, then we can't do anything.
Can copying the results of `toArray` ensure accuracy and security? It has too many possible problems. Maybe the size of the array is wrong, maybe it forgot to copy the contents of the collection and all it returns is an array full of nulls.
To put it one step further, is its iterator necessarily correct? Perhaps its iterator implementation is also incorrect:
class BadList implements List<Object> {
private Object[] array;
// ...
public Iterator<Object> iterator(){
return new Iterator<Object>() {
int i = 0;
public boolean hasNext() {
return true;
}
public Object next() {
array[i++] = null;
return new Object(); // crazy implementation
}
};
}
}
But who cares? Since its implementation is incorrect, it is normal for it to suffer for itself. We only need to prevent errors from being leaked to other places, rather than defending against all errors.
-------------
PR Comment: https://git.openjdk.org/jdk/pull/13383#issuecomment-1501390568
More information about the core-libs-dev
mailing list