Comment comparer personnage ignorant la casse dans les types primitifs

Vous ne pouvez pas fait faire le travail tout à fait à droite avec toLowerCase, soit sur une chaîne ou à un personnage. Le problème, c'est qu'il y a des variantes de glyphes en majuscules ou en minuscules, et selon que vous en majuscules ou en minuscules vos glyphes peuvent ou ne peuvent pas être conservés. Il n'est même pas clair ce que vous dire quand vous dites que deux variantes d'un bas-de-casse glyphe sont comparés ignorant la casse: sont-ils ou ne sont-ils pas les mêmes? (Noter qu'il existe également mélangé glyphes: \u01c5, \u01c8, \u01cb, \u01f2 ou dž, lj, nj, dz, mais toute méthode proposée ici permettra de travailler sur ceux, aussi longtemps qu'ils devraient compter que la même chose que leurs pleinement supérieure ou complète de minuscules variantes.)

Il y a un problème supplémentaire avec l'aide de Char: il y a 80 points de code non représentable avec un seul Char qui sont en majuscules/minuscules variantes (40), au moins tel que détecté par Java du point de code en haut/en bas du boîtier. Par conséquent, vous devez obtenir les points de code et de modifier le cas sur ces.

Mais les points de code n'aide pas avec les variantes de glyphes.

De toute façon, voici une liste complète des glyphes qui sont problématiques en raison de variantes, en montrant comment ils se comportent à l'encontre de 6 variante méthodes:

1. Caractère toLowerCase
2. Caractère toUpperCase
3. Chaîne toLowerCase
4. Chaîne toUpperCase
5. Chaîne equalsIgnoreCase
6. Caractère toLowerCase(toUpperCase) (ou vice versa)

Pour ces méthodes, S signifie que les variantes sont traités de la même manière que de l'autre, D signifie que les variantes sont considérés comme différents les uns des autres.

Behavior     Unicode                             Glyphs
===========  ==================================  =========
1 2 3 4 5 6  Upper  Lower  Var Up Var Lo Vr Lo2  U L u l l2
- - - - - -  ------ ------ ------ ------ ------  - - - - -
D D D D S S  \u0049 \u0069 \u0130 \u0131         I i İ ı   
S D S D S S  \u004b \u006b \u212a                K k K     
D S D S S S  \u0053 \u0073        \u017f         S s   ſ   
D S D S S S  \u039c \u03bc        \u00b5         Μ μ   µ   
S D S D S S  \u00c5 \u00e5 \u212b                Å å Å     
D S D S S S  \u0399 \u03b9        \u0345 \u1fbe  Ι ι   ͅ ι 
D S D S S S  \u0392 \u03b2        \u03d0         Β β   ϐ   
D S D S S S  \u0395 \u03b5        \u03f5         Ε ε   ϵ   
D D D D S S  \u0398 \u03b8 \u03f4 \u03d1         Θ θ ϴ ϑ   
D S D S S S  \u039a \u03ba        \u03f0         Κ κ   ϰ   
D S D S S S  \u03a0 \u03c0        \u03d6         Π π   ϖ   
D S D S S S  \u03a1 \u03c1        \u03f1         Ρ ρ   ϱ   
D S D S S S  \u03a3 \u03c3        \u03c2         Σ σ   ς   
D S D S S S  \u03a6 \u03c6        \u03d5         Φ φ   ϕ   
S D S D S S  \u03a9 \u03c9 \u2126                Ω ω Ω     
D S D S S S  \u1e60 \u1e61        \u1e9b         Ṡ ṡ   ẛ   

Ce qui complique encore davantage, c'est que il n'y a aucun moyen d'obtenir le turc j'ai le droit (c'est à dire en pointillés versions différentes de la undotted versions), sauf si vous savez que vous êtes dans le turc; aucune de ces méthodes ne donnent comportement correct et ne peuvent pas, sauf si vous savez de la locale (c'est à dire non-turc: i et I sont les mêmes ignorant la casse; turc, pas).

Dans l'ensemble, à l'aide de toUpperCase vous donne l'approximation la plus proche, puisque vous avez seulement cinq majuscules variantes (ou quatre, sans compter les turcs).

Vous pouvez également essayer spécifiquement pour intercepter les cinq gênants cas et appel toUpperCase(toLowerCase(c)) à eux seuls. Si vous choisissez votre gardiens de soin (juste toUpperCase si c < 0x130 || c > 0x212B, puis de travailler à travers les autres solutions), vous pouvez obtenir une ~20% de la vitesse de pénalité pour les caractères dans la plage basse (par rapport à ~4x si vous convertissez les caractères uniques sur les cordes et les equalsIgnoreCase eux), et seul un 2x pénalité si vous avez beaucoup dans la zone de danger. Vous avez encore la locale problème avec pointillés I, mais sinon, vous êtes dans une forme décente. Bien sûr, si vous pouvez utiliser equalsIgnoreCase sur une grande chaîne, vous feriez mieux de faire ça.

Voici un exemple de code Scala qui fait le travail:

def elevateCase(c: Char): Char = {
  if (c < 0x130 || c > 0x212B) Character.toUpperCase(c)
  else if (c == 0x130 || c == 0x3F4 || c == 0x2126 || c >= 0x212A)
    Character.toUpperCase(Character.toLowerCase(c))
  else Character.toUpperCase(c)
}

OriginalL'auteur Rex Kerr

Vous pourriez mettre les deux caractères en minuscules et de les comparer.

OriginalL'auteur assylias

Méthodes génériques pour comparer un char à une position entre 2 chaînes de caractères à ignorer la casse.

public static boolean isEqualIngoreCase(char one, char two){
    return Character.toLowerCase(one)==Character .toLowerCase(two);
}

public static boolean isEqualStringCharIgnoreCase(String one, String two, int position){
    char oneChar = one.charAt(position);
    char twoChar = two.charAt(position);
    return isEqualIngoreCase(oneChar, twoChar);
}

Appel de fonction

boolean isFirstCharEqual = isEqualStringCharIgnoreCase("abc", "ABC", 0)

OriginalL'auteur Siddarth Kanted