8365675: Add String.toCaseFold()

xuemingshen-oracle · xuemingshen-oracle · commit 4bb3ea4201c2 · 2025-08-18T03:20:04.000-07:00
diff --git a/make/jdk/src/classes/build/tools/generatecharacter/CaseFolding.java b/make/jdk/src/classes/build/tools/generatecharacter/CaseFolding.java
@@ -29,45 +29,82 @@
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.nio.file.StandardOpenOption;
+import java.util.Arrays;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 public class CaseFolding {
 
     public static void main(String[] args) throws Throwable {
-        if (args.length != 3) {
-            System.err.println("Usage: java CaseFolding TemplateFile CaseFolding.txt CaseFolding.java");
+        if (args.length != 4) {
+            System.err.println("Usage: java CaseFolding TemplateFile CaseFolding.txt CaseFolding.java lang");
             System.exit(1);
         }
         var templateFile = Paths.get(args[0]);
         var caseFoldingTxt = Paths.get(args[1]);
         var genSrcFile = Paths.get(args[2]);
-        var supportedTypes = "^.*; [CTS]; .*$";
-        var caseFoldingEntries = Files.lines(caseFoldingTxt)
-            .filter(line -> !line.startsWith("#") && line.matches(supportedTypes))
-            .map(line -> {
-                String[] cols = line.split("; ");
-                return new String[] {cols[0], cols[1], cols[2]};
-            })
-            .filter(cols -> {
-                //  the folding case doesn't map back to the original char.
-                var cp1 = Integer.parseInt(cols[0], 16);
-                var cp2 = Integer.parseInt(cols[2], 16);
-                return Character.toUpperCase(cp2) != cp1 && Character.toLowerCase(cp2) != cp1;
-            })
-            .map(cols -> String.format("        entry(0x%s, 0x%s)", cols[0], cols[2]))
-            .collect(Collectors.joining(",\n", "", ""));
+        var pkg = args[3];
 
-        // hack, hack, hack! the logic does not pick 0131. just add manually to support 'I's.
-        // 0049; T; 0131; # LATIN CAPITAL LETTER I
-        final String T_0x0131_0x49 = String.format("        entry(0x%04x, 0x%04x),\n", 0x0131, 0x49);
+        if ("lang_string".equals(pkg)) {
+            var supportedTypes = "^.*; [CF]; .*$";  // full/1:M case folding
+            var caseFoldingEntries = Files.lines(caseFoldingTxt)
+                    .filter(line -> !line.startsWith("#") && line.matches(supportedTypes))
+                    .map(line -> {
+                        var fields = line.split("; ");
+                        var cp = Integer.parseInt(fields[0], 16);
+                        fields = fields[2].trim().split(" ");
+                        var folding = new int[fields.length];
+                        for (int i = 0; i < folding.length; i++) {
+                            folding[i] = Integer.parseInt(fields[i], 16);
+                        }
+                        var foldingChars = Arrays.stream(folding)
+                                .mapToObj(Character::toChars)
+                                .flatMapToInt(chars -> IntStream.range(0, chars.length).map(i -> (int)chars[i]))
+                                .toArray();
+                        return String.format("\t\tnew CaseFoldingEntry(0x%04x, %s)",
+                                cp,
+                                Arrays.stream(foldingChars)
+                                        .mapToObj(c -> String.format("0x%04x", c))
+                                        .collect(Collectors.joining(", ", "new char[] {", "}"))
+                        );
+                    })
+                    .collect(Collectors.joining(",\n", "", ""));
 
-        // Generate .java file
-        Files.write(
-            genSrcFile,
-            Files.lines(templateFile)
-                .map(line -> line.contains("%%%Entries") ? T_0x0131_0x49 + caseFoldingEntries : line)
-                .collect(Collectors.toList()),
-            StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
+            Files.write(
+                    genSrcFile,
+                    Files.lines(templateFile)
+                            .map(line -> line.contains("%%%Entries") ? caseFoldingEntries : line)
+                            .collect(Collectors.toList()),
+                    StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
+        } else {
+            var supportedTypes = "^.*; [CTS]; .*$";
+            var caseFoldingEntries = Files.lines(caseFoldingTxt)
+                    .filter(line -> !line.startsWith("#") && line.matches(supportedTypes))
+                    .map(line -> {
+                        String[] cols = line.split("; ");
+                        return new String[]{cols[0], cols[1], cols[2]};
+                    })
+                    .filter(cols -> {
+                        //  the folding case doesn't map back to the original char.
+                        var cp1 = Integer.parseInt(cols[0], 16);
+                        var cp2 = Integer.parseInt(cols[2], 16);
+                        return Character.toUpperCase(cp2) != cp1 && Character.toLowerCase(cp2) != cp1;
+                    })
+                    .map(cols -> String.format("        entry(0x%s, 0x%s)", cols[0], cols[2]))
+                    .collect(Collectors.joining(",\n", "", ""));
+
+            // hack, hack, hack! the logic does not pick 0131. just add manually to support 'I's.
+            // 0049; T; 0131; # LATIN CAPITAL LETTER I
+            final String T_0x0131_0x49 = String.format("        entry(0x%04x, 0x%04x),\n", 0x0131, 0x49);
+
+            // Generate .java file
+            Files.write(
+                    genSrcFile,
+                    Files.lines(templateFile)
+                            .map(line -> line.contains("%%%Entries") ? T_0x0131_0x49 + caseFoldingEntries : line)
+                            .collect(Collectors.toList()),
+                    StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
+        }
     }
 }
diff --git a/make/modules/java.base/gensrc/GensrcCharacterData.gmk b/make/modules/java.base/gensrc/GensrcCharacterData.gmk
@@ -72,5 +72,23 @@ TARGETS += $(GENSRC_CHARACTERDATA)
 
 ################################################################################
 
+
+GENSRC_STRINGCASEFOLDING := $(SUPPORT_OUTPUTDIR)/gensrc/java.base/jdk/internal/java/lang/CaseFolding.java
+
+STRINGCASEFOLDING_TEMPLATE := $(MODULE_SRC)/share/classes/jdk/internal/lang/CaseFolding.java.template
+CASEFOLDINGTXT := $(MODULE_SRC)/share/data/unicodedata/CaseFolding.txt
+
+$(GENSRC_STRINGCASEFOLDING): $(BUILD_TOOLS_JDK) $(STRINGCASEFOLDING_TEMPLATE) $(CASEFOLDINGTXT)
+	$(call LogInfo, Generating $@)
+	$(call MakeTargetDir)
+	$(TOOL_GENERATECASEFOLDING) \
+	    $(STRINGCASEFOLDING_TEMPLATE) \
+	    $(CASEFOLDINGTXT) \
+	    $(GENSRC_STRINGCASEFOLDING) \
+	    lang_string
+
+TARGETS += $(GENSRC_STRINGCASEFOLDING)
+
+
 endif # include guard
 include MakeIncludeEnd.gmk
diff --git a/make/modules/java.base/gensrc/GensrcRegex.gmk b/make/modules/java.base/gensrc/GensrcRegex.gmk
@@ -61,7 +61,8 @@ $(GENSRC_CASEFOLDING): $(BUILD_TOOLS_JDK) $(CASEFOLDINGTEMP) $(CASEFOLDINGTXT)
 	$(TOOL_GENERATECASEFOLDING) \
 	    $(CASEFOLDINGTEMP) \
 	    $(CASEFOLDINGTXT) \
-	    $(GENSRC_CASEFOLDING)
+	    $(GENSRC_CASEFOLDING) \
+	    util_regex
 
 TARGETS += $(GENSRC_CASEFOLDING)
 
diff --git a/src/java.base/share/classes/java/lang/String.java b/src/java.base/share/classes/java/lang/String.java
@@ -3791,6 +3791,47 @@ public String toUpperCase() {
         return toUpperCase(Locale.getDefault());
     }
 
+    /**
+     * Returns a case-folded copy of this {@code String}, using the Unicode
+     * case folding mappings defined in
+     * <a href="https://www.unicode.org/Public/UCD/latest/ucd/CaseFolding.txt">
+     * Unicode Case Folding Properties</a>.
+     *
+     * <p>Case folding is a locale-independent, language-neutral form of
+     * case mapping, primarily intended for case-insensitive matching.
+     * Unlike {@link #toLowerCase()} or {@link #toUpperCase()}, which are
+     * designed for locale-sensitive or display-oriented transformations,
+     * case folding provides a stable and consistent mapping across all
+     * environments. It may include one-to-many mappings; for example,
+     * the German sharp s ({@code U+00DF}) folds to the sequence
+     * {@code "ss"}.
+     *
+     * <p>This method performs the "Full" case folding as defined in the
+     * Unicode CaseFolding data file. The result is suitable for use in
+     * case-insensitive string comparison, searching, or indexing.
+     *
+     * @apiNote
+     * Case folding is intended for caseless matching, not for locale-sensitive
+     * presentation. For example:
+     *
+     * <pre>{@code
+     * String a = "Maße";
+     * String b = "MASSE";
+     * if (a.toCaseFold().equals(b.toCaseFold())) {
+     *     // true, matches according to Unicode case-insensitive rules
+     * }
+     * }</pre>
+     *
+     * @return a {@code String} containing the case-folded form of this string
+     * @see #toLowerCase()
+     * @see #toUpperCase()
+     */
+
+    public String toCaseFold() {
+        return isLatin1() ? StringLatin1.toCaseFold(this, value)
+                          : StringUTF16.toCaseFold(this, value);
+    }
+
     /**
      * Returns a string whose value is this string, with all leading
      * and trailing space removed, where space is defined
diff --git a/src/java.base/share/classes/java/lang/StringLatin1.java b/src/java.base/share/classes/java/lang/StringLatin1.java
@@ -32,6 +32,7 @@
 import java.util.function.IntConsumer;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
+import jdk.internal.java.lang.CaseFolding;
 import jdk.internal.util.ArraysSupport;
 import jdk.internal.vm.annotation.IntrinsicCandidate;
 
@@ -560,6 +561,54 @@ private static String toUpperCaseEx(String str, byte[] value,
         return StringUTF16.newString(result, 0, resultOffset);
     }
 
+    private static String toCaseFoldEx(String str, byte[] value, int first) {
+        byte[] result = StringUTF16.newBytesFor(value.length);
+        int resultOffset = 0;
+        for (int i = 0; i < first; i++) {
+            StringUTF16.putChar(result, resultOffset++, value[i] & 0xff);
+        }
+        for (int i = first; i < value.length; i++) {
+            int cp = value[i] & 0xff;
+            char[] folded = CaseFolding.fold(cp);
+            if (folded.length == 1) {
+                StringUTF16.putChar(result, resultOffset++, folded[0]);
+            } else {
+                byte[] result2 = StringUTF16.newBytesFor((result.length >> 1) + folded.length - 1);
+                System.arraycopy(result, 0, result2, 0, resultOffset << 1);
+                result = result2;
+                for (int x = 0; x < folded.length; ++x) {
+                    StringUTF16.putChar(result, resultOffset++, folded[x]);
+                }
+            }
+        }
+        return StringUTF16.newString(result, 0, resultOffset);
+    }
+
+    public static String toCaseFold(String str, byte[] value) {
+        int first;
+        final int len = value.length;
+        // Now check if there are any characters that need to be changed
+        for (first = 0 ; first < len; first++) {
+            var cp = value[first] & 0xff;
+            if (!CaseFolding.isFolded(value[first] & 0xff)) {
+                break;
+            }
+        }
+        if (first == len)
+            return str;
+        byte[] result = new byte[len];
+        System.arraycopy(value, 0, result, 0, first);  // Just copy the first few
+        // fold characters
+        for (int i = first; i < len; i++) {
+            var folded = CaseFolding.fold(value[i] & 0xff);
+            if (folded.length > 1 || !canEncode(folded[0])) {
+                return toCaseFoldEx(str, value, first);
+            }
+            result[i] = (byte)(folded[0] & 0xff);
+        }
+        return new String(result, LATIN1);
+    }
+
     public static String trim(byte[] value) {
         int len = value.length;
         int st = 0;
diff --git a/src/java.base/share/classes/java/lang/StringUTF16.java b/src/java.base/share/classes/java/lang/StringUTF16.java
@@ -34,6 +34,7 @@
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
+import jdk.internal.java.lang.CaseFolding;
 import jdk.internal.misc.Unsafe;
 import jdk.internal.util.ArraysSupport;
 import jdk.internal.vm.annotation.ForceInline;
@@ -1164,6 +1165,77 @@ private static String toUpperCaseEx(String str, byte[] value,
         return newString(result, 0, resultOffset);
     }
 
+    private static String toCaseFoldEx(String str, byte[] value, byte[] result, int first) {
+        assert(result.length == value.length);
+        assert(first >= 0);
+        int resultOffset = first;
+        int length = value.length >> 1;
+        int srcCount;
+        for (int i = first; i < length; i += srcCount) {
+            int src = getChar(value, i);
+            srcCount = 1;
+            if (Character.isSurrogate((char)src)) {
+                src = codePointAt(value, i, length);
+                srcCount = Character.charCount(src);
+            }
+            char[] folded = CaseFolding.fold(src);
+            if (folded.length > srcCount) {
+                // tbd: should we pre-scan?
+                byte[] result2 = newBytesFor((result.length >> 1) + folded.length - srcCount);
+                System.arraycopy(result, 0, result2, 0, resultOffset << 1);
+                result = result2;
+            }
+            assert resultOffset >= 0;
+            assert resultOffset + folded.length <= length(result);
+            for (int x = 0; x < folded.length; ++x) {
+                putChar(result, resultOffset++, folded[x]);
+            }
+        }
+        return newString(result, 0, resultOffset);
+    }
+
+    public static String toCaseFold(String str, byte[] value) {
+        int first;
+        final int len = value.length >> 1;
+        int cpCount = 1;
+
+        // Now check if there are any characters that need to be changed, or are surrogate
+        for (first = 0 ; first < len; first += cpCount) {
+            int cp = (int)getChar(value, first);
+            if (Character.isSurrogate((char)cp)) {
+                cp = codePointAt(value, first, len);
+             }
+            if (!CaseFolding.isFolded(cp)) {
+                break;
+            }
+            cpCount = Character.charCount(cp);
+        }
+        if (first == len) {
+            return str;
+        }
+        byte[] result = new byte[value.length];
+        System.arraycopy(value, 0, result, 0, first << 1); // Just copy the first few
+        // case-fold characters.
+        int bits = 0;
+        for (int i = first; i < len; i++) {
+            int cp = (int)getChar(value, i);
+            if (Character.isSurrogate((char)cp)) {
+                return toCaseFoldEx(str, value, result, i);
+            }
+            char[] folded = CaseFolding.fold(cp);
+            if (folded.length != 1) {    // 1:M or surrogate pair
+                return toCaseFoldEx(str, value, result, i);
+            }
+            bits |= folded[0];
+            putChar(result, i, folded[0]);
+        }
+        if (bits < 0 || bits > 0xff) {
+            return new String(result, UTF16);
+        } else {
+            return newString(result, 0, len);
+        }
+    }
+
     public static String trim(byte[] value) {
         int length = value.length >> 1;
         int len = length;
diff --git a/src/java.base/share/classes/jdk/internal/lang/CaseFolding.java.template b/src/java.base/share/classes/jdk/internal/lang/CaseFolding.java.template
diff --git a/test/jdk/java/lang/String/UnicodeCaseFoldingTest.java b/test/jdk/java/lang/String/UnicodeCaseFoldingTest.java
diff --git a/test/micro/org/openjdk/bench/java/lang/StringToCaseFold.java b/test/micro/org/openjdk/bench/java/lang/StringToCaseFold.java
