Add public StringUtilities.getChars(String) for fast char[] access

New public API returns a ThreadLocal char[] populated via String.getChars()
(SIMD bulk copy). Callers replace str.charAt(i) with buf[i] to avoid
per-character method call and JDK 9+ coder check overhead.

hashCodeIgnoreCase now uses this public method. Any hot loop across
java-util, json-io, or downstream projects can benefit with:
  char[] buf = StringUtilities.getChars(str);
  for (int i = 0; i < str.length(); i++) { buf[i] ... }

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Claude4.0o

changelog.md

@@ -1,7 +1,8 @@
 ### Revision History
 
 #### 4.99.0 (Unreleased)
-* **PERFORMANCE**: `StringUtilities.hashCodeIgnoreCase(String)` — uses `String.getChars()` (SIMD-optimized bulk copy) into a ThreadLocal `char[]` buffer, then hashes from the array directly. Avoids `charAt()`'s per-character method call and JDK 9+ compact-string coder check overhead. No reflection, no VarHandle, no `--add-opens` — works on all JDK versions (8-25+). Benchmark shows CaseInsensitiveMap GET improved **70-75%** (230 → 58-69 ns/op), PUT improved **48-52%** (135 → 65-71 ns/op), and MIXED-CASE GET improved **68%** (302 → 93-97 ns/op) on 100K entries.
+* **FEATURE**: New `StringUtilities.getChars(String s)` — public API that returns a ThreadLocal `char[]` buffer populated via `String.getChars()` (SIMD-optimized bulk copy). Callers can replace `str.charAt(i)` loops with direct `buf[i]` array access, avoiding per-character method call and JDK 9+ coder check overhead. Use `s.length()` for the valid range. Buffer is shared per-thread — valid until the next `getChars()` call on the same thread.
+* **PERFORMANCE**: `StringUtilities.hashCodeIgnoreCase(String)` — uses `StringUtilities.getChars()` (SIMD-optimized bulk copy) into a ThreadLocal `char[]` buffer, then hashes from the array directly. Avoids `charAt()`'s per-character method call and JDK 9+ compact-string coder check overhead. No reflection, no VarHandle, no `--add-opens` — works on all JDK versions (8-25+). Benchmark shows CaseInsensitiveMap GET improved **70-75%** (230 → 58-69 ns/op), PUT improved **48-52%** (135 → 65-71 ns/op), and MIXED-CASE GET improved **68%** (302 → 93-97 ns/op) on 100K entries.
 * **PERFORMANCE**: New `FastReader.readLine(char[] dest, int off, int maxLen)` — dedicated line-reading method optimized for TOON's line-oriented parsing. Combines scanning, copying, and line-ending consumption (`\n`, `\r`, `\r\n`) into a single call. Uses a `c <= '\r'` range guard so printable characters (the vast majority) require only one comparison per character instead of two. Eliminates the per-line overhead of separate `readUntil()` + `read()` + pushback round-trip. JFR shows TOON line-reading samples dropped from 173 to 125 (28% reduction), and `FastReader.read()` calls halved (53 → 25 samples).
 * **PERFORMANCE**: `FastReader.readUntil()` pushback drain loop now uses a local variable for `pushbackPosition` instead of repeated member field access, avoiding load/store through `this` on each iteration. JFR shows 14.8% reduction in aggregate FastReader CPU share.
 * **PERFORMANCE**: `FastReader.readUntil()` replaced `Math.min()` call with inline ternary in the tight buffer-scan loop, eliminating method call overhead. JFR confirmed 3.5% wall-clock improvement.

src/main/java/com/cedarsoftware/util/StringUtilities.java

@@ -974,11 +974,7 @@ public static int hashCodeIgnoreCase(String s) {
         if (s == null) return 0;
 
         final int n = s.length();
-        // Bulk-copy chars via getChars (SIMD-optimized), then hash from the array.
-        // Avoids charAt()'s per-character method call and JDK 9+ coder check overhead.
-        // Uses no reflection, no VarHandle — works on all JDK versions.
-        char[] buf = getCharBuf(n);
-        s.getChars(0, n, buf, 0);
+        char[] buf = getChars(s);
 
         int h = 0;
         for (int i = 0; i < n; i++) {
@@ -996,7 +992,31 @@ public static int hashCodeIgnoreCase(String s) {
         return h;
     }
 
-    /** Get a reusable char buffer from ThreadLocal, growing if needed. */
+    /**
+     * Returns a ThreadLocal {@code char[]} buffer populated with the string's characters
+     * via {@link String#getChars(int, int, char[], int)} (SIMD-optimized bulk copy).
+     * <p>
+     * Use {@code s.length()} for the valid range — the returned buffer may be larger.
+     * <p>
+     * This avoids {@code charAt()}'s per-character method call and JDK 9+ compact-string
+     * coder check overhead. Callers can loop over the returned array with direct array access
+     * instead of {@code str.charAt(i)}.
+     * <p>
+     * <b>Important:</b> The returned array is a shared ThreadLocal buffer. It is valid only
+     * until the next call to {@code getChars()} on the same thread. Do not store the reference
+     * beyond the immediate scope.
+     *
+     * @param s the string whose characters to extract (must not be null)
+     * @return a char[] containing the string's characters starting at index 0
+     */
+    public static char[] getChars(String s) {
+        int n = s.length();
+        char[] buf = getCharBuf(n);
+        s.getChars(0, n, buf, 0);
+        return buf;
+    }
+
+    /** Internal: get a reusable char buffer from ThreadLocal, growing if needed. */
     private static char[] getCharBuf(int minSize) {
         char[] buf = TL_CHAR_BUF.get();
         if (minSize > buf.length) {