CaseInsensitiveComparator in java/lang/String.java has multiple similar looking if-s in it.

I am reproducing the exact code for `CASE_INSENSITIVE_ORDER` comparator in java/lang/String.java.

   public static final Comparator<String> CASE_INSENSITIVE_ORDER                                         = new CaseInsensitiveComparator();    private static class CaseInsensitiveComparator            implements Comparator<String>, java.io.Serializable {        // use serialVersionUID from JDK 1.2.2 for interoperability        private static final long serialVersionUID = 8575799808933029326L;        public int compare(String s1, String s2) {            int n1 = s1.length();            int n2 = s2.length();            int min = Math.min(n1, n2);            for (int i = 0; i < min; i++) {                char c1 = s1.charAt(i);                char c2 = s2.charAt(i);                if (c1 != c2) {                    c1 = Character.toUpperCase(c1);                    c2 = Character.toUpperCase(c2);                    if (c1 != c2) {                        c1 = Character.toLowerCase(c1);                        c2 = Character.toLowerCase(c2);                        if (c1 != c2) {                            // No overflow because of numeric promotion                            return c1 - c2;                        }                    }                }            }            return n1 - n2;        } }

Why are we doing two character comparsions inside the Comparator. One after converting them to upper-case & the other converting to lower-case. Is there any scenario, that the second `toLowerCase` call captures that in fact, `toUpperCase` doesn't capture. I am saying, the compare function can it be written as,
public int compare(String s1, String s2) {            int n1 = s1.length();            int n2 = s2.length();            int min = Math.min(n1, n2);            for (int i = 0; i < min; i++) {                char c1 = s1.charAt(i);                char c2 = s2.charAt(i);                if (c1 != c2) {                    c1 = Character.toUpperCase(c1);                    c2 = Character.toUpperCase(c2);                     if (c1 != c2) {                            // No overflow because of numeric promotion                            return c1 - c2;                    }                }            }            return n1 - n2;        }

The German letter ẞ traditionally didn't have an upper‑case form. If you want to convert it to upper‑case you have to use SS. If you convert that to lower‑case, it becomes ss.

saravana arumugam wrote:Is there any scenario, that the second `toLowerCase` call captures that in fact, `toUpperCase` doesn't capture.

Sure, there's lots. I wrote a small program to find them all.

The first example was &#181;, which looks like µ and is called "Micro Sign" in Unicode. Its upper case version is &#924;, which looks like Μ and is called "Greek Capital Letter Mu" in Unicode. And finally the lower case version of &#924; is &#956;, which looks like μ and is called "Greek Small Letter Mu" in Unicode.

Actually it turns out that my program didn't do what you asked it to do, sorry. Your question, I believe, is "Are there two different characters for which (1) their upper-case versions are different but (2) the lower-case versions of those upper-case versions are the same."

And yes, there are. Here's one: compare "I" (capital letter I) to "İ" (dotted capital letter I (used in Turkish)). Their upper-case versions are also I and İ -- but the lower-case versions of those two characters are both "i" (lower-case letter I).

So "I" and "İ" are case-insensitively equal according to the API code, but not according to yours. There's a few more of these.

The Unicode Standard, Version 17.0 wrote:. . .
00B5 μ MICRO SIGN
≈ 03BC μ greek small letter mu . . .

0x00b5 is 181 in decimal.
Should the micro sign have an upper‑case equivalent in the first place?

Campbell Ritchie wrote:Should the micro sign have an upper‑case equivalent in the first place?

Indeed it should. This table from the Unicode standard confirms it. Which isn't surprising because Java supports Unicode and has done so since Java 1.0.

It's also worth mentioning that the code we're discussing compares strings one character at a time, rather than one code point at a time. It is also not locale-sensitive (see my example of Turkish I). So it's basically obsolete and you shouldn't be using it any more.

However the original question in this post is still relevant to better versions  of the code, since they still work that way.

Paul Clapham wrote:. . . Indeed it should. . . .

Just because it looks like a μ, and μ definitely has an upper‑case equivalent doesn't mean the micro sign should have an upper‑case equivalent. The Unicode chart doesn't say that U+00B5 has an upper‑case equivalent but it does mention μ, The Greek chart has μ and Μ almost next to each other, so if you know, it is obvious that they are intended to be paired like that. The names also include CAPITAL and SMALL, which are the names I learnt as a little schoolboy.
Let's try it on JShell:-

jshell> String s1 = "\u00b5";
s1 ==> "µ"

jshell> String s2 = "\u03bc";
s2 ==> "μ"

jshell> String.CASE_INSENSITIVE_ORDER.compare(s1, s2);
$3 ==> 0

jshell> s1.compareTo(s2);
$4 ==> -775

I think they have read something into Unicode that isn't in Unicode in the first place.

not locale-sensitive . . . basically obsolete . . . .

The documentation for CASE_INSENSITIVE_ORDER recommends using a Collator.

Thank you all for presenting unicode cases that i hadn't explored earlier.....

That's a pleasure

Campbell Ritchie wrote:The Unicode chart doesn't say that U+00B5 has an upper‑case equivalent...

Unicode wrote:00B5;MICRO SIGN;Ll;0;L;<compat> 03BC;;;;N;;;039C;;039C

says that its upper-case equivalent is U+039C. (And that it doesn't have a lower-case equivalent and that its title-case equivalent is U+039C.)

Found that here; I had never seen that site before.