This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
The following commit(s) were added to refs/heads/master by this push:
new de6417d43 Speedup CharSequenceUtils.toCharArray(CharSequence)
de6417d43 is described below
commit de6417d43d061fd5ef17fb12d8bb7d07ac47a9ac
Author: Gary Gregory <[email protected]>
AuthorDate: Thu Dec 18 17:45:19 2025 -0500
Speedup CharSequenceUtils.toCharArray(CharSequence)
- StringBuilder Performance Gain: 160-205% improvement (2-3x faster)
- StringBuffer Performance Gain: 300-4,250% improvement (4-44x faster)
- String: ~1-2% improvement (essentially identical)
- This change was suggested by Claude Sonnet 4.5
---
src/changes/changes.xml | 3 +
.../apache/commons/lang3/CharSequenceUtils.java | 12 +-
.../commons/lang3/CharSequenceUtilsBenchmark.java | 194 +++++++++++++++++++++
3 files changed, 208 insertions(+), 1 deletion(-)
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 0618873bc..3ad3fd1d1 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -81,6 +81,9 @@ The <action> type attribute can be add,update,fix,remove.
<action issue="LANG-1803" type="fix" dev="ggregory" due-to="IcoreE">Fix
incorrect method invocation in ObjectUtilsTest and Javadoc reference in
RandomStringUtils.</action>
<action issue="LANG-1695" type="fix" dev="ggregory" due-to="Guillaume
Nodet, Harshit Goel, Gary Gregory">Allow trailing decimal point in
NumberUtils.isParsable #1531.</action>
<action issue="LANG-1804" type="fix" dev="ggregory" due-to="IcoreE, Gary
Gregory">Fix CharSet#getInstance returns null instead of EMPTY when input
setStrs is null #1530.</action>
+ <action type="fix" dev="ggregory" due-to="Gary
Gregory">Speedup CharSequenceUtils.toCharArray(CharSequence) for StringBuilder
input: 160-205% improvement (2-3x faster), see
CharSequenceUtilsBenchmark.</action>
+ <action type="fix" dev="ggregory" due-to="Gary
Gregory">Speedup CharSequenceUtils.toCharArray(CharSequence) for StringBuffer
input: 300-4,250% improvement (4-44x faster), see
CharSequenceUtilsBenchmark.</action>
+ <action type="fix" dev="ggregory" due-to="Gary
Gregory">Speedup CharSequenceUtils.toCharArray(CharSequence) for String input:
~1-2% improvement (essentially identical).</action>
<!-- ADD -->
<!-- UPDATE -->
<action type="update" dev="ggregory" due-to="Gary
Gregory, Dependabot">Bump org.apache.commons:commons-parent from 92 to 93
#1498.</action>
diff --git a/src/main/java/org/apache/commons/lang3/CharSequenceUtils.java
b/src/main/java/org/apache/commons/lang3/CharSequenceUtils.java
index df79c8fe2..0477d1201 100644
--- a/src/main/java/org/apache/commons/lang3/CharSequenceUtils.java
+++ b/src/main/java/org/apache/commons/lang3/CharSequenceUtils.java
@@ -70,7 +70,7 @@ static int indexOf(final CharSequence cs, final CharSequence
searchChar, final i
// return cs.toString().indexOf(searchChar.toString(), start);
// }
}
-
+
/**
* Returns the index within {@code cs} of the first occurrence of the
specified character, starting the search at the specified index.
* <p>
@@ -371,6 +371,16 @@ public static char[] toCharArray(final CharSequence
source) {
if (source instanceof String) {
return ((String) source).toCharArray();
}
+ if (source instanceof StringBuilder) {
+ final char[] array = new char[len];
+ ((StringBuilder) source).getChars(0, len, array, 0);
+ return array;
+ }
+ if (source instanceof StringBuffer) {
+ final char[] array = new char[len];
+ ((StringBuffer) source).getChars(0, len, array, 0);
+ return array;
+ }
final char[] array = new char[len];
for (int i = 0; i < len; i++) {
array[i] = source.charAt(i);
diff --git
a/src/test/java/org/apache/commons/lang3/CharSequenceUtilsBenchmark.java
b/src/test/java/org/apache/commons/lang3/CharSequenceUtilsBenchmark.java
new file mode 100644
index 000000000..e0e726e08
--- /dev/null
+++ b/src/test/java/org/apache/commons/lang3/CharSequenceUtilsBenchmark.java
@@ -0,0 +1,194 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.lang3;
+
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+/**
+ * Benchmark comparing the old and new implementations of CharSequenceUtils
methods.
+ *
+ * <p>
+ * Run with:
+ * </p>
+ *
+ * <pre>
+ * mvn -P benchmark clean test
-Dbenchmark=org.apache.commons.lang3.CharSequenceUtilsBenchmark
+ * </pre>
+ * <p>
+ * Results:
+ * </p>
+ *
+ * <pre>
+Benchmark (charSequenceType)
(length) Mode Cnt Score Error Units
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent String
10 avgt 5 1.626 ± 0.011 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent String
50 avgt 5 2.741 ± 0.029 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent String
100 avgt 5 4.235 ± 0.038 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent String
500 avgt 5 17.713 ± 0.273 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent String
1000 avgt 5 34.692 ± 1.752 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuilder
10 avgt 5 1.963 ± 0.047 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuilder
50 avgt 5 4.085 ± 0.042 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuilder
100 avgt 5 5.978 ± 0.177 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuilder
500 avgt 5 25.616 ± 1.621 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuilder
1000 avgt 5 53.749 ± 0.420 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuffer
10 avgt 5 7.239 ± 0.149 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuffer
50 avgt 5 9.061 ± 0.187 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuffer
100 avgt 5 10.281 ± 0.055 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuffer
500 avgt 5 29.647 ± 0.420 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayCurrent StringBuffer
1000 avgt 5 56.203 ± 0.505 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew String
10 avgt 5 1.657 ± 0.030 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew String
50 avgt 5 2.771 ± 0.094 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew String
100 avgt 5 4.281 ± 0.036 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew String
500 avgt 5 17.744 ± 0.091 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew String
1000 avgt 5 34.224 ± 0.251 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuilder
10 avgt 5 1.962 ± 0.128 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuilder
50 avgt 5 4.101 ± 0.035 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuilder
100 avgt 5 5.984 ± 0.062 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuilder
500 avgt 5 25.448 ± 0.152 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuilder
1000 avgt 5 54.531 ± 0.559 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuffer
10 avgt 5 7.260 ± 0.175 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuffer
50 avgt 5 8.537 ± 0.101 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuffer
100 avgt 5 10.502 ± 0.143 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuffer
500 avgt 5 29.584 ± 0.339 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayNew StringBuffer
1000 avgt 5 56.751 ± 0.983 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld String
10 avgt 5 1.656 ± 0.231 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld String
50 avgt 5 2.770 ± 0.222 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld String
100 avgt 5 4.298 ± 0.198 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld String
500 avgt 5 18.023 ± 0.203 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld String
1000 avgt 5 35.053 ± 1.467 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuilder
10 avgt 5 3.164 ± 0.062 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuilder
50 avgt 5 8.907 ± 0.185 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuilder
100 avgt 5 15.801 ± 0.104 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuilder
500 avgt 5 77.203 ± 0.460 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuilder
1000 avgt 5 164.064 ± 2.506 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuffer
10 avgt 5 28.981 ± 0.307 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuffer
50 avgt 5 126.285 ± 1.688 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuffer
100 avgt 5 250.584 ± 5.639 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuffer
500 avgt 5 1231.478 ± 51.296 ns/op
+CharSequenceUtilsBenchmark.benchmarkToCharArrayOld StringBuffer
1000 avgt 5 2453.553 ± 54.004 ns/op
+ * </pre>
+ *
+ */
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Thread)
+@Fork(1)
+@Warmup(iterations = 3, time = 1)
+@Measurement(iterations = 5, time = 1)
+public class CharSequenceUtilsBenchmark {
+
+ /**
+ * New optimized implementation of toCharArray.
+ */
+ public static char[] toCharArrayNew(final CharSequence source) {
+ final int len = StringUtils.length(source);
+ if (len == 0) {
+ return ArrayUtils.EMPTY_CHAR_ARRAY;
+ }
+ if (source instanceof String) {
+ return ((String) source).toCharArray();
+ }
+ // NEW: Uses bulk getChars() for StringBuilder/StringBuffer
+ if (source instanceof StringBuilder) {
+ final char[] array = new char[len];
+ ((StringBuilder) source).getChars(0, len, array, 0);
+ return array;
+ }
+ if (source instanceof StringBuffer) {
+ final char[] array = new char[len];
+ ((StringBuffer) source).getChars(0, len, array, 0);
+ return array;
+ }
+ final char[] array = new char[len];
+ for (int i = 0; i < len; i++) {
+ array[i] = source.charAt(i);
+ }
+ return array;
+ }
+
+ /**
+ * Old implementation of toCharArray.
+ */
+ public static char[] toCharArrayOld(final CharSequence source) {
+ final int len = StringUtils.length(source);
+ if (len == 0) {
+ return ArrayUtils.EMPTY_CHAR_ARRAY;
+ }
+ if (source instanceof String) {
+ return ((String) source).toCharArray();
+ }
+ // OLD: Always uses charAt() loop, even for StringBuilder/StringBuffer
+ final char[] array = new char[len];
+ for (int i = 0; i < len; i++) {
+ array[i] = source.charAt(i);
+ }
+ return array;
+ }
+
+ @Param({ "10", "50", "100", "500", "1000" })
+ public int length;
+ @Param({ "String", "StringBuilder", "StringBuffer" })
+ public String charSequenceType;
+ private CharSequence testSequence;
+
+ @Benchmark
+ public char[] benchmarkToCharArrayCurrent() {
+ return CharSequenceUtils.toCharArray(testSequence);
+ }
+ @Benchmark
+ public char[] benchmarkToCharArrayNew() {
+ return toCharArrayNew(testSequence);
+ }
+
+ @Benchmark
+ public char[] benchmarkToCharArrayOld() {
+ return toCharArrayOld(testSequence);
+ }
+
+ @Setup(Level.Trial)
+ public void setup() {
+ final StringBuilder sb = new StringBuilder(length);
+ for (int i = 0; i < length; i++) {
+ sb.append((char) ('a' + i % 26));
+ }
+ final String content = sb.toString();
+ switch (charSequenceType) {
+ case "String":
+ testSequence = content;
+ break;
+ case "StringBuilder":
+ testSequence = new StringBuilder(content);
+ break;
+ case "StringBuffer":
+ testSequence = new StringBuffer(content);
+ break;
+ }
+ }
+}
