Summary

New method CharSequence.getChars(int, int, char[], int) on java.lang.CharSequence to bulk-read characters from a region in the CharSequence into a region of the provided char[].

Problem

CharSequence interface does not provide a bulk-read facility. Some CharSequence implementations do not support bulk-reading at all, while others (like String and CharBuffer) do support bulk-reading but do not share a common method signature to perform it.

Applications wanting to bulk-read from CharSequence must contain a (theoretically infinite) list of bulk-reading solutions, e. g. (copied from Reader.of(CharSequence) in JDK 24):

switch (cs) {
    case String s -> s.getChars(next, next + n, cbuf, off);
    case StringBuilder sb -> sb.getChars(next, next + n, cbuf, off);
    case StringBuffer sb -> sb.getChars(next, next + n, cbuf, off);
    case CharBuffer cb -> cb.get(next, cbuf, off, n);
    default -> {
        for (int i = 0; i < n; i++)
            cbuf[off + i] = cs.charAt(next + i);
    }
}

The motivation for the new method is performance as sequential reading is expensive.

Solution

Add a new method public void getChars(int, int, char[], int) to CharSequence and CharBuffer.

Specification

String:

/**
 * {@inheritDoc CharSequence}
 * @param srcBegin {@inheritDoc CharSequence}
 * @param srcEnd   {@inheritDoc CharSequence}
 * @param dst      {@inheritDoc CharSequence}
 * @param dstBegin {@inheritDoc CharSequence}
 * @throws IndexOutOfBoundsException {@inheritDoc CharSequence}
 */
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

StringBuffer and StringBuilder:

/**
 * {@inheritDoc CharSequence}
 */
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

CharSequence:

/**
 * Copies characters from this sequence into the given destination array.
 * The first character to be copied is at index {@code srcBegin}; the last
 * character to be copied is at index {@code srcEnd-1}. The total number of
 * characters to be copied is {@code srcEnd-srcBegin}. The
 * characters are copied into the subarray of {@code dst} starting
 * at index {@code dstBegin} and ending at index:
 * <pre>{@code
 * dstbegin + (srcEnd-srcBegin) - 1
 * }</pre>
 *
 * @param      srcBegin   start copying at this offset.
 * @param      srcEnd     stop copying at this offset.
 * @param      dst        the array to copy the data into.
 * @param      dstBegin   offset into {@code dst}.
 * @throws     IndexOutOfBoundsException  if any of the following is true:
 *             <ul>
 *             <li>{@code srcBegin} is negative
 *             <li>{@code dstBegin} is negative
 *             <li>the {@code srcBegin} argument is greater than
 *             the {@code srcEnd} argument.
 *             <li>{@code srcEnd} is greater than
 *             {@code this.length()}.
 *             <li>{@code dstBegin+srcEnd-srcBegin} is greater than
 *             {@code dst.length}
 *             </ul>
 * @throws     NullPointerException if {@code dst} is {@code null}
 *
 * @implSpec
 * The default implementation invokes {@link #charAt(int index)} in a loop
 * iterating {@code index} from {@code srcBegin} to {@code srcEnd-1}.
 * Concurrent truncation of this character sequence can throw
 * {@code IndexOutOfBoundsException}. In this case, some characters, but not
 * all, may be already transferred.
 *
 * @since 25
 */
public default void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

CharBuffer:

/**
 * Absolute bulk <i>get</i> method.
 *
 * <p> This method transfers {@code srcEnd-srcBegin} characters from this
 * buffer into the given array, starting at index {@code srcBegin} in this
 * buffer and at offset {@code dstBegin} in the array. The position of this
 * buffer is unchanged.
 *
 * @param  srcBegin
 *         The index in this buffer from which the first character will be
 *         read; must be non-negative and less than {@code limit()}
 *
 * @param  srcEnd
 *         The index in this buffer directly before the last character to
 *         read; must be non-negative and less or equal than {@code limit()}
 *         and must be greater or equal than {@code srcBegin}
 *
 * @param  dst
 *         The destination array
 *
 * @param  dstBegin
 *         The offset within the array of the first character to be
 *         written; must be non-negative and less than {@code dst.length}
 *
 * @throws  IndexOutOfBoundsException
 *          If the preconditions on the {@code srcBegin}, {@code srcEnd},
 *          and {@code dstBegin} parameters do not hold
 *
 * @implSpec This method is equivalent to
 *           {@code get(srcBegin, dst, dstBegin, srcEnd - srcBegin)}.
 *
 * @since 25
 */
@Override
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)