Comment utiliser equalsIgnoreCase() pour de multiples éléments en java

if(string.equalsIgnoreCase("first") || 
string.equalsIgnoreCase("second") || string.equalsIgnoreCase("third"))

J'ai besoin d'utiliser 10 || ici (j'ai 10 chaînes à vérifier).Est-il une solution simple pour cela.

Et j'ai besoin de trouver la condition est satisfaite.

Merci d'avance..

OriginalL'auteur PSR | 2013-05-29

java

6

Si vous avez besoin de savoir qui correspondent est vrai, puis d'utiliser un commutateur (Java 7):
```
switch (string.toLowerCase())
{
    case "first": doSomething();
        break;
    case "second": ...;
        break;
    default: ...;
}
```
S'il vous plaît être conscient que cet idiome peut conduire à des résultats surprenants en fonction du courant de locale avec des caractères non-ascii.
Vous avez raison, je ne pense jamais à l'avance et n'a jamais eu à faire face à de tels endroits, donc je n'ai pas le prendre en compte.

OriginalL'auteur Djon
7

Vous pouvez utiliser string.matches() qui prend une expression régulière dans laquelle vous pouvez contraindre les première, deuxième, troisième, etc:
```
if (string.matches("first|second|third"))
```
ou, pour le compte de la casse:
```
if (string.matches("(?i)first|second|third"))
```
Les expressions régulières sont complexes, mais pourrait être un problème de performance.

est-il possible de savoir ce qui est vrai match
Si c'est ce que vous faites dans la méthode, voir ma réponse sur les commutateurs.
Non, c'est l'équivalent de plusieurs votre | de la| dans la question. Si vous voulez connaître qui correspondent, sans doute la meilleure chose à faire est de diviser le "si". Vous pouvez toujours utiliser des expressions régulières pour les éléments communs. Ou commutateur de cordes et de faire usage de 'suivre'.
Désolé, c'était l'écriture de cet avant que j'ai vu Djon commentaire: en effet, considérons un commutateur.

OriginalL'auteur Bathsheba
4

Vous pourriez vouloir utiliser un Set<String> et de vérifier si cela contient souhaité String.
```
TreeSet<String> values = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);

values.put("first");
values.put("second");
values.put("third");

if (values.contains(string.toLower())) {
}
```
Cela fonctionne dans temps logarithmique (O(log n)), tandis que le ||-est (en théorie, dans le pire des cas) linéaire. Pour 10 éléments, il n'est guère pertinent.

Modifier (les crédits vont à Walter):

La TreeSet classe utilise la Comparator uniquement pour déterminer l'égalité, plutôt que d'utiliser equals méthode. Vous pouvez donc mettre des majuscules et des minuscules cordes. À partir de la La classe TreeSet documentation:

Noter que la commande est maintenue par un ensemble (que ce soit ou non explicitement
comparateur est fourni) doit être compatible avec égal à égal si c'est pour
mettre correctement en œuvre l'Ensemble de l'interface. (Voir Comparables ou Comparateur
pour une définition précise de la cohérence avec d'égal à égal.) C'est donc
parce que l'Ensemble de l'interface est définie dans les termes de l'égale de l'opération,
mais un TreeSet instance effectue tous les éléments de comparaisons à l'aide de son
compareTo (ou de comparer les) méthode, donc, deux éléments qui sont considérés comme égaux
par cette méthode sont, du point de vue de l'ensemble, de l'égalité. L'
le comportement d'un ensemble bien défini, même si son classement est incompatible
avec égal à égal; simplement, il ne respecte pas les conditions générales du contrat de l'Ensemble
de l'interface.

Ou utiliser new TreeSet<String>(String.CASE_INSENSITIVE_ORDER).
Mais les valeurs n'ont pas besoin d'être triés ici.
J'ai besoin de l'essayer plus tard, mais je pense que la comparaison ne change que le ordre de tri, mais pas le fait que contains utilise equals pour vérifier si un élément est celui qui est recherché.
sortes l'élément de construire un arbre pour la recherche rapide. Ils ont donc besoin d'être triés, si je suis d'accord ce n'est pas de l'intérêt de RP.
contient également utiliser la méthode de comparaison: a TreeSet instance performs all element comparisons using its compareTo (or compare) method, so two elements that are deemed equal by this method are, from the standpoint of the set, equal. The behavior of a set is well-defined even if its ordering is inconsistent with equals; it just fails to obey the general contract of the Set interface.

OriginalL'auteur Matthias Meid

vous pouvez utiliser votre propre fonction:

equalsIgnoreCase("string", "first", "second");

public boolean equalsIgnoreCase(String needle, String... haystack) {
    foreach(String s : haystack) {
        if(needle.equalsIgnoreCase(s)) {
            return true;
        }
    }

    return false;
}

Pourquoi faut-il retourner false en trouver un match?
Très bonne question, sans doute trop tôt le matin.

OriginalL'auteur kelunik

Ici est de Java 8 et ruisseaux de la solution

String string = "...";

List<String> match = Arrays.asList("first", "second", "third", "...");

if (match.stream().anyMatch(string::equalsIgnoreCase)) {
    //...
}

OriginalL'auteur djm.im

Vous devez vous connecter pour publier un commentaire.