java - jradiobutton example

Curioso acerca de la implementación de CaseInsensitiveComparator

Question

Esta pregunta ya tiene una respuesta aquí:

• Entendiendo la lógica en las respuestas de CaseInsensitiveComparator 5

Mientras CaseInsensitiveComparator la implementación de CaseInsensitiveComparator , que es una clase interna privada de String , encontré algo extraño.

private static class CaseInsensitiveComparator
        implements Comparator<String>, java.io.Serializable {
    ...
    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;
    }
    ...
}

Lo que tengo curiosidad es esto: en el bucle for , una vez que compara los caracteres en mayúsculas superiores, ¿por qué debería comparar los caracteres en mayúsculas de nuevo? Cuando Character.toUpperCase(c1) y Character.toUpperCase(c2) son diferentes, ¿es posible que Character.toLowerCase(c1) y Character.toLowerCase(c2) sean iguales?

¿No podría ser simplificado 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;
}

¿Me he perdido algo?

Answer 1

Hay caracteres Unicode que son diferentes en minúsculas, pero tienen la misma forma en mayúsculas. Por ejemplo, la letra griega Sigma: tiene dos formas en minúsculas (σ, y ς que solo se usan al final de la palabra), pero solo una en mayúsculas (Σ).

No pude encontrar ningún ejemplo de lo contrario, pero si tal situación sucediera en el futuro, la implementación actual de Java ya está preparada para esto. Su versión del Comparator definitivamente manejaría el caso Sigma correctamente.

Puede encontrar más información en las Preguntas frecuentes sobre asignación de casos en el sitio web de Unicode.