Java: String: equalsIgnoreCase vs commutation tout en majuscules/minuscules

il est venu à mon attention qu'il y a plusieurs façons de comparer les chaînes en Java.

je viens de recevoir l'habitude il y a des siècles à utiliser equalsIgnoreCase pour éviter les problèmes avec les cordes sensibles à la casse.

d'Autres en revanche préfèrent passer tout en majuscules ou en minuscules.

de mon point de vue (même si techniquement je suis assis), Je ne vois pas de réelle différence.

est ce que quelqu'un sait si une pratique est meilleure que l'autre? Et si oui, pourquoi?

24
demandé sur Paul T. 2010-12-15 07:17:53
la source

8 ответов

Utiliser equalsIgnoreCase parce que c'est plus lisible que de convertir les deux chaînes en majuscules avant une comparaison. la lisibilité l'emporte sur la micro-optimisation.

Ce qui est plus lisible?

if (myString.toUpperCase().equals(myOtherString.toUpperCase())) {

ou

if (myString.equalsIgnoreCase(myOtherString)) {

je pense que nous pouvons tous convenir que equalsIgnoreCase est plus lisible.

46
répondu Asaph 2010-12-15 07:23:25
la source

equalsIgnoreCase évite les problèmes concernant les différences spécifiques à une localité (par exemple, dans la turque, il y a deux majuscules différentes "i"). D'un autre côté, les cartes N'utilisent que la méthode equals ().

8
répondu koljaTM 2013-04-18 16:41:25
la source

mais la question dans le dernier, où vous faites un hypothèse que la majuscule ou la minuscule soit passée, vous ne pouvez pas faire confiance aveuglément à l'appelant. Donc, vous devez inclure un ASSERT déclaration au début de la méthode pour s'assurer que l'entrée est toujours dans le cas où vous attend.

3
répondu rkg 2010-12-15 07:34:21
la source

il n'est Ni mieux, ils ont tous deux leurs utilisations dans différents scénarios.

plusieurs fois quand vous devez faire des comparaisons de cordes, il y a la possibilité de masser au moins une des cordes pour la rendre plus facile à comparer, et dans ces cas vous verrez des cordes converties en un cas particulier, taillées, etc avant d'être comparées.

si, d'un autre côté, vous voulez juste faire une comparaison à la volée non sensible à la casse de deux cordes alors n'hésitez pas à utiliser equalsIgnoreCase, c'est ce son là après tout. Je tiens cependant à préciser que si vous voyez beaucoup de equalsIgnoreCase il pourrait être une odeur de code.

1
répondu CurtainDog 2010-12-15 13:58:44
la source

Performance sage la fois sont les mêmes en fonction de ce post:

http://www.params.me/2011/03/stringtolowercasestringtouppercase-vs.html

donc je déciderais en me basant sur le code readabilty, dans certains cas toLowerCase() serait mieux si je passais une valeur toujours à une seule méthode pour créer des objets, sinon equalsIgnoreCase() a plus de sens.

1
répondu Sileria 2012-06-27 13:35:43
la source

Quand je travaille seulement en anglais des personnages, j'ai toujours run toUpperCase() ou toLowerCase() avant de commencer à faire des comparaisons si j'appelle .equalsIgnoreCase()plus d'une fois ou si j'utilise un switch déclaration. De cette façon, il ne fait le cas-opération de changement qu'une seule fois, et est donc plus efficace.

Par exemple, dans une usine modèle:

public static SuperObject objectFactory(String objectName) {
    switch(objectName.toUpperCase()) {
        case "OBJECT1":
            return new SubObject1();
            break;
        case "OBJECT2":
            return new SubObject2();
            break;
        case "OBJECT3":
            return new SubObject3();
            break;
    }
    return null;
}

(en utilisant un switch déclaration est légèrement plus rapide que if..else if..else blocs de comparaison de chaînes de caractères)

0
répondu 4castle 2016-05-13 09:01:19
la source

Cela dépend du cas d'utilisation.

si vous faites une comparaison de chaîne à une, equalsIgnoreCase est probablement plus rapide, car à l'intérieur il ne fait que mettre en majuscules chaque caractère alors qu'il itère à travers les chaînes (le code ci-dessous est de java.lang.String), qui est un peu plus rapide que les majuscules ou les minuscules avant d'effectuer la même comparaison:

if (ignoreCase) 
{
    // If characters don't match but case may be ignored,
    // try converting both characters to uppercase.
    // If the results match, then the comparison scan should
    // continue.
    char u1 = Character.toUpperCase(c1);
    char u2 = Character.toUpperCase(c2);
    if (u1 == u2) {
        continue;
    }
    // Unfortunately, conversion to uppercase does not work properly
    // for the Georgian alphabet, which has strange rules about case
    // conversion.  So we need to make one last check before
    // exiting.
    if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
        continue;
    }
}

Mais quand vous avez une situation où vous voulez faire des recherches contre une structure de données pleine de chaînes (en particulier les cordes qui sont toutes dans l'espace Latin/ASCII des États-Unis) de manière insensible à la casse, il sera plus rapide de couper/minuscules les cordes à vérifier et de les mettre dans quelque chose comme un HashSet ou HashMap.

c'est mieux que d'appeler equalsIgnoreCase sur chaque élément d'une liste parce que le léger gain de performance d'equalsIgnoreCase() est annulé par le fait que vous faites essentiellement une version modifiée de contains() contre un tableau, qui est O(n). Avec un chaîne pré-normalisée vous pouvez vérifier la liste complète des chaînes avec un seul appel contains() qui s'exécute dans O(1).

0
répondu Jim W 2016-11-02 19:31:45
la source

documentation equalsIgnoreCase en jdk 8

  • compare cette chaîne à une autre chaîne, ignorant le cas considération. Deux chaînes sont considérées comme cas égal ignorant si elles sont de la même longueur et les caractères correspondants dans les deux chaînes sont égaux ignorant cas.

    deux caractères c1 et c2 sont considérés comme identiques ignorer le cas si au moins un des cas suivants est vrai:

    • les deux caractères sont les mêmes (comparés par l'opérateur == )
    • application de la méthode java.lang.Characttoupercase (char)à chaque caractère produit le même résultat
    • application de la méthode java.lang.CharactertoLowerCase (char) à chaque caractère produit le même résultat

Mes pensées:

donc en utilisant equalsIgnoreCase nous itérons à travers les chaînes (seulement si leurs valeurs de taille sont les mêmes) en comparant chaque char. Dans dans le pire des cas, la performance sera O( 3cn ) où n = La Taille de vos cordes. Nous utiliserons pas d'espace supplémentaire.

en utilisant toUpper() puis en comparant si les chaînes sont égales, vous faites toujours une boucle à travers chaque chaîne une fois, en convertissant toutes les chaînes en haut, puis faites une équivalence par vérification de référence (égale ())). C'est theta(2n + c). Mais rappelez-vous, quand vous faites toUpperCase(), vous devez en fait créer deux nouvelles chaînes parce que les chaînes en Java sont immuables.

Donc J'Ai dirais que equalsIgnoreCase est à la fois plus efficace et plus facile à lire.

Encore une fois je considère le cas d'utilisation, parce que ce serait ce qu'il vient pour moi. L'approche toUpper pourrait être valide dans certains cas d'utilisation, mais 98% du temps j'utilise equalsIgnoreCase().

0
répondu andrew dibiasio 2018-01-31 19:53:54
la source

Autres questions sur