Comment déterminer si un tableau contient une valeur particulière en Java?

2279

J'ai un String[]avec des valeurs comme ça:

public static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

Étant donné String s, existe-t-il un bon moyen de vérifier si VALUEScontient s?

Mike Sickler
la source
5
Le chemin est long, mais vous pouvez utiliser une boucle for: "for (String s: VALUES) if (s.equals (" MYVALUE ")) return true;
Zack
70
@camickr. A votre question, j'ai voté en faveur de cette question et de votre réponse -maintenant- car cela m'a fait gagner 30 minutes et 20 lignes de code écrivant moche pour les boucles, -maintenant-. Je ne l'ai pas lu il y a trois ans. (BTW, merci :))
Poursuite
3
@ camickr - J'ai une situation presque identique avec celui-ci: stackoverflow.com/a/223929/12943 Il ne fait que continuer à obtenir des votes, c'était juste un copier / coller de la documentation de sun. Je suppose que le score est basé sur la quantité d'aide que vous avez fournie et non sur l'effort que vous y avez consacré - et surtout sur la vitesse à laquelle vous la publiez! Peut-être que nous sommes tombés sur le secret de John Skeet! Eh bien bonne réponse, +1 pour vous.
Bill K
1
Si vous utilisez Apache Commons, org.apache.commons.lang.ArrayUtils.contains () le fait pour vous.
M. Boy
34
@camickr parce que les gens, comme moi, recherchent une question sur Google, cliquent sur le résultat SO, voient votre réponse, testez-la, cela fonctionne, votez la réponse, puis partez.
Aequitas

Réponses:

2925
Arrays.asList(yourArray).contains(yourValue)

Attention: cela ne fonctionne pas pour les tableaux de primitives (voir les commentaires).


Depuis vous pouvez désormais utiliser Streams.

String[] values = {"AB","BC","CD","AE"};
boolean contains = Arrays.stream(values).anyMatch("s"::equals);

Pour vérifier si un tableau de int, doubleou longcontient une valeur, utilisez IntStream, DoubleStreamou LongStreamrespectivement.

Exemple

int[] a = {1,2,3,4};
boolean contains = IntStream.of(a).anyMatch(x -> x == 4);
camickr
la source
87
Je suis quelque peu curieux quant aux performances de ceci par rapport aux fonctions de recherche dans la classe Arrays par rapport à l'itération sur un tableau et en utilisant une fonction equals () ou == pour les primitives.
Thomas Owens
186
Vous ne perdez pas grand-chose, car asList () renvoie une ArrayList qui a un tableau en son cœur. Le constructeur va juste changer une référence donc ce n'est pas beaucoup de travail à faire là-bas. Et contient () / indexOf () itérera et utilisera equals (). Pour les primitives, vous feriez mieux de le coder vous-même. Pour les cordes ou autres classes, la différence ne sera pas perceptible.
Joey
18
Bizarrement, NetBeans prétend que «Arrays.asList (jours fériés)» pour un «jours fériés int [] renvoie une« liste <int []> », et non une« liste <int> ». Il ne contient qu'un seul élément. Ce qui signifie que le contenu ne fonctionne pas car il n'a qu'un seul élément; le tableau int.
Nyerguds
62
Nyerguds: en effet, cela ne fonctionne pas pour les primitifs. En java, les types primitifs ne peuvent pas être génériques. asList est déclaré comme <T> List <T> asList (T ...). Lorsque vous lui passez un int [], le compilateur déduit T = int [] car il ne peut pas déduire T = int, car les primitives ne peuvent pas être génériques.
CromTheDestroyer
28
@Joey juste une note de côté, il est un ArrayList, mais pas java.util.ArrayListcomme prévu, la vraie classe retournée est: java.util.Arrays.ArrayList<E>définie comme suit: public class java.util.Arrays {private static class ArrayList<E> ... {}}.
TWiStErRob
363

Mise à jour concise pour Java SE 9

Les tableaux de référence sont mauvais. Pour ce cas, nous recherchons un ensemble. Depuis Java SE 9, nous l'avons Set.of.

private static final Set<String> VALUES = Set.of(
    "AB","BC","CD","AE"
);

"Étant donné String s, existe-t-il un bon moyen de tester si VALUES contient s?"

VALUES.contains(s)

O (1).

Le bon type , immuable , O (1) et concis . Beau.*

Détails de la réponse d'origine

Juste pour effacer le code pour commencer. Nous avons (corrigé):

public static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

Il s'agit d'une statique mutable que FindBugs vous dira très coquine. Ne modifiez pas la statique et n'autorisez pas d'autres codes à le faire également. Au minimum, le champ doit être privé:

private static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

(Remarque, vous pouvez réellement laisser tomber le new String[];bit.)

Les tableaux de référence sont toujours mauvais et nous voulons un ensemble:

private static final Set<String> VALUES = new HashSet<String>(Arrays.asList(
     new String[] {"AB","BC","CD","AE"}
));

(Les personnes paranoïaques, comme moi, pourraient se sentir plus à l'aise si cela était enveloppé Collections.unmodifiableSet- cela pourrait même être rendu public.)

(* Pour être un peu plus sur la marque, il est prévisible que l'API des collections manque encore de types de collections immuables et la syntaxe est encore beaucoup trop verbeuse, à mon goût.)

Tom Hawtin - sellerie
la source
184
Sauf que c'est O (N) pour créer la collection en premier lieu :)
Drew Noakes
61
S'il est statique, il sera probablement utilisé plusieurs fois. Ainsi, le temps consacré à l'initialisation de l'ensemble a de bonnes chances d'être assez petit par rapport au coût de nombreuses recherches linéaires.
Xr.
1
La création de la collection sera alors dominée par le temps de chargement du code (qui est techniquement O (n) mais pratiquement constant).
Tom Hawtin - tackline
2
@ TomHawtin-tackline Pourquoi dites-vous "en particulier ici, nous voulons un ensemble"? Quel est l'avantage d'un Set (HashSet) dans ce cas? Pourquoi un «tableau de référence» est-il mauvais (par «tableau de référence», voulez-vous dire une ArrayList sauvegardée par un tableau généré par un appel à Arrays.asList)?
Basil Bourque
6
@nmr A le TreeSetserait O(log n). HashSets sont mis à l'échelle de telle sorte que le nombre moyen d'éléments dans un compartiment est à peu près constant. Au moins pour les tableaux jusqu'à 2 ^ 30. Il peut y avoir des effets provenant, par exemple, de caches matériels que l'analyse big-O ignore. Suppose également que la fonction de hachage fonctionne efficacement.
Tom Hawtin - tackline
206

Vous pouvez utiliser ArrayUtils.containsdepuis Apache Commons Lang

public static boolean contains(Object[] array, Object objectToFind)

Notez que cette méthode retourne falsesi le tableau passé est null.

Il existe également des méthodes disponibles pour les tableaux primitifs de toutes sortes.

Exemple:

String[] fieldsToInclude = { "id", "name", "location" };

if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}
Intracer
la source
4
@ max4ever Je suis d'accord, mais c'est encore mieux que "rouler le vôtre" et plus facile à lire que la manière java brute.
Jason
2
package: org.apache.commons.lang.ArrayUtils
slamborne
38
@ max4ever Parfois, vous avez déjà cette bibliothèque incluse (pour d'autres raisons) et c'est une réponse parfaitement valable. Je cherchais cela et je dépends déjà d'Apache Commons Lang. Merci pour cette réponse.
GuiSim
1
Ou vous pouvez simplement copier la méthode (et les dépendances s'il y en a).
Buffalo
10
@ max4ever La plupart des applications Android sont minimisées par Proguard, ne mettant que les classes et les fonctions dont vous avez besoin dans votre application. Cela équivaut à rouler le vôtre ou à copier la source de la chose Apache. Et celui qui n'utilise pas cette minimisation n'a pas à se plaindre de 700kb ou 78kb :)
Kenyakorn Ketsombut
158

Il suffit de l'implémenter à la main:

public static <T> boolean contains(final T[] array, final T v) {
    for (final T e : array)
        if (e == v || v != null && v.equals(e))
            return true;

    return false;
}

Amélioration:

La v != nullcondition est constante à l'intérieur de la méthode. Il évalue toujours la même valeur booléenne lors de l'appel de méthode. Donc, si l'entrée arrayest grande, il est plus efficace d'évaluer cette condition une seule fois, et nous pouvons utiliser une condition simplifiée / plus rapide à l'intérieur de la forboucle en fonction du résultat. La contains()méthode améliorée :

public static <T> boolean contains2(final T[] array, final T v) {
    if (v == null) {
        for (final T e : array)
            if (e == null)
                return true;
    } 
    else {
        for (final T e : array)
            if (e == v || v.equals(e))
                return true;
    }

    return false;
}
icza
la source
9
@Phoexo Cette solution est évidemment plus rapide car la réponse acceptée enveloppe le tableau dans une liste et appelle la méthode contains () sur cette liste tandis que ma solution fait essentiellement ce que contient () seulement.
icza
10
@AlastorMoody e == v effectue une vérification d'égalité de référence qui est très rapide. Si le même objet (identique par référence) se trouve dans le tableau, il sera trouvé plus rapidement. S'il ne s'agit pas de la même instance, elle pourrait toujours être la même que celle revendiquée par la méthode equals (), c'est ce qui est vérifié si les références ne sont pas les mêmes.
icza
20
Pourquoi cette fonction ne fait-elle pas partie de Java? Pas étonnant que les gens disent que Java est gonflé ... regardez toutes les réponses ci-dessus qui utilisent un tas de bibliothèques quand tout ce dont vous avez besoin est une boucle for. Les enfants de nos jours!
phreakhead du
4
@phreakhead Il fait partie de Java, voirCollection.contains(Object)
Steve Kuo
11
@icza Si vous regardez la source de Arrayset ArrayListil s'avère que ce n'est pas nécessairement plus rapide que la version utilisant Arrays.asList(...).contains(...). La surcharge de la création d'un ArrayListest extrêmement petite et ArrayList.contains()utilise une boucle plus intelligente (en fait, elle utilise deux boucles différentes) que celle illustrée ci-dessus (JDK 7).
Axel
72

Quatre façons différentes de vérifier si un tableau contient une valeur

1) Utilisation de la liste:

public static boolean useList(String[] arr, String targetValue) {
    return Arrays.asList(arr).contains(targetValue);
}

2) Utilisation de Set:

public static boolean useSet(String[] arr, String targetValue) {
    Set<String> set = new HashSet<String>(Arrays.asList(arr));
    return set.contains(targetValue);
}

3) En utilisant une boucle simple:

public static boolean useLoop(String[] arr, String targetValue) {
    for (String s: arr) {
        if (s.equals(targetValue))
            return true;
    }
    return false;
}

4) Utilisation de Arrays.binarySearch ():

Le code ci-dessous est incorrect, il est répertorié ici pour être complet. binarySearch () ne peut être utilisé que sur des tableaux triés. Vous trouverez le résultat bizarre ci-dessous. C'est la meilleure option lorsque le tableau est trié.

public static boolean binarySearch(String[] arr, String targetValue) {  
            int a = Arrays.binarySearch(arr, targetValue);
            return a > 0;
        }

Exemple rapide:

String testValue="test";
String newValueNotInList="newValue";
String[] valueArray = { "this", "is", "java" , "test" };
Arrays.asList(valueArray).contains(testValue); // returns true
Arrays.asList(valueArray).contains(newValueNotInList); // returns false
Sireesh Yarlagadda
la source
5
votre exemple de recherche binaire doit retourner un> 0;
Will Sherwood
6
Pourquoi? Je pense qu'il devrait retourner un> -1, puisque 0 indiquerait qu'il est contenu en tête du tableau.
mbelow
1
La première variante avec (a >= 0)était correcte, il suffit de vérifier les documents , ils disent "Notez que cela garantit que la valeur de retour sera> = 0 si et seulement si la clé est trouvée".
Yoory N.
Pourquoi fonctionne sur String et non sur int? un booléen statique existe (int [] ints, int k) {return Arrays.asList (ints) .contains (k); }
Willians Martins
71

Si le tableau n'est pas trié, vous devrez parcourir tout et faire un appel à égal sur chacun.

Si le tableau est trié, vous pouvez faire une recherche binaire, il y en a un dans la classe Arrays .

De manière générale, si vous devez effectuer de nombreuses vérifications d'appartenance, vous souhaiterez peut-être tout stocker dans un ensemble, pas dans un tableau.

Uri
la source
1
De plus, comme je l'ai dit dans ma réponse, si vous utilisez la classe Arrays, vous pouvez trier le tableau puis effectuer la recherche binaire sur le tableau nouvellement trié.
Thomas Owens
1
@Thomas: Je suis d'accord. Ou vous pouvez simplement tout ajouter dans un TreeSet; même complexité. J'utiliserais les tableaux s'il ne change pas (peut-être économiser un peu de localité de mémoire car les références sont situées de manière contiguë bien que les chaînes ne le soient pas). J'utiliserais l'ensemble si cela devait changer avec le temps.
Uri
49

Pour ce que ça vaut j'ai fait un test comparant les 3 suggestions de vitesse. J'ai généré des entiers aléatoires, les ai convertis en chaîne et les ai ajoutés à un tableau. J'ai ensuite cherché le nombre / chaîne le plus élevé possible, ce qui serait le pire des cas pour le asList().contains().

Lors de l'utilisation d'une taille de tableau de 10 Ko, les résultats étaient les suivants:

Trier et rechercher: 15
Recherche binaire: 0
asList.contains: 0

Lors de l'utilisation d'un tableau 100K, les résultats étaient les suivants:

Tri & Recherche: 156
Recherche binaire: 0
asList.contient: 32

Donc, si le tableau est créé dans un ordre trié, la recherche binaire est la plus rapide, sinon ce asList().containsserait la voie à suivre. Si vous avez plusieurs recherches, il peut être utile de trier le tableau afin que vous puissiez utiliser la recherche binaire. Tout dépend de votre application.

Je pense que ce sont les résultats auxquels la plupart des gens s'attendent. Voici le code de test:

import java.util.*;

public class Test
{
    public static void main(String args[])
    {
        long start = 0;
        int size = 100000;
        String[] strings = new String[size];
        Random random = new Random();


        for (int i = 0; i < size; i++)
            strings[i] = "" + random.nextInt( size );

        start = System.currentTimeMillis();
        Arrays.sort(strings);
        System.out.println(Arrays.binarySearch(strings, "" + (size - 1) ));
        System.out.println("Sort & Search : " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        System.out.println(Arrays.binarySearch(strings, "" + (size - 1) ));
        System.out.println("Search        : " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        System.out.println(Arrays.asList(strings).contains( "" + (size - 1) ));
        System.out.println("Contains      : " + (System.currentTimeMillis() - start));
    }
}
camickr
la source
6
Je ne comprends pas ce code. Vous triez les «chaînes» du tableau et utilisez le même tableau (trié) dans les deux appels à binarySearch. Comment cela peut-il montrer autre chose que l'optimisation de l'exécution HotSpot? La même chose avec l'appel asList.contains. Vous créez une liste à partir du tableau trié, puis ne contient dessus avec la valeur la plus élevée. Bien sûr, cela va prendre du temps. Quelle est la signification de ce test? Sans oublier d'être un microbenchmark mal écrit
Erik
De plus, comme la recherche binaire ne peut être appliquée qu'à un ensemble trié, le tri et la recherche sont le seul moyen possible d'utiliser la recherche binaire.
Erik
Le tri peut avoir déjà été effectué pour un certain nombre d'autres raisons, par exemple, il peut être trié sur init et ne jamais être modifié. Il est utile de tester seul le temps de recherche. Cependant, là où cela tombe, c'est d'être un exemple moins que stellaire de micro-analyse comparative. Les microbenchmarks sont notoirement difficiles à obtenir correctement en Java et devraient par exemple inclure l'exécution du code de test suffisamment pour obtenir une optimisation de hotspot avant d'exécuter le test réel, et encore moins d'exécuter le code de test réel plus d'une fois avec une minuterie. Exemples d'embûches
Thor84no
7
Ce test est défectueux car il exécute les 3 tests dans la même instance JVM. Les derniers tests pourraient bénéficier des précédents qui réchauffent le cache, JIT, etc.
Steve Kuo
4
Ce test est en fait totalement indépendant. Sort & Search est une complexité linéithmique (n * log (n)), la recherche binaire est logarithmique et ArrayUtils.contains est évidemment linéaire. Il est inutile de comparer ces solutions car elles sont dans des classes de complexité totalement différentes.
dragn
37

Au lieu d'utiliser également la syntaxe d'initialisation rapide des tableaux, vous pouvez simplement l'initialiser sous forme de liste de la même manière en utilisant la méthode Arrays.asList, par exemple:

public static final List<String> STRINGS = Arrays.asList("firstString", "secondString" ...., "lastString");

Ensuite, vous pouvez faire (comme ci-dessus):

STRINGS.contains("the string you want to find");
Mark Rhodes
la source
36

Avec Java 8, vous pouvez créer un flux et vérifier si des entrées dans le flux correspondent "s":

String[] values = {"AB","BC","CD","AE"};
boolean sInArray = Arrays.stream(values).anyMatch("s"::equals);

Ou comme méthode générique:

public static <T> boolean arrayContains(T[] array, T value) {
    return Arrays.stream(array).anyMatch(value::equals);
}
assylias
la source
3
Il convient également de noter les spécialisations primitives.
skiwi
Pour ajouter également, anyMatchJavaDoc le déclare "...May not evaluate the predicate on all elements if not necessary for determining the result.", il n'est donc pas nécessaire de poursuivre le traitement après avoir trouvé une correspondance.
mkobit
28

Vous pouvez utiliser la classe Arrays pour effectuer une recherche binaire de la valeur. Si votre tableau n'est pas trié, vous devrez utiliser les fonctions de tri de la même classe pour trier le tableau, puis le parcourir.

Thomas Owens
la source
Vous pouvez utiliser les fonctions de tri dans la même classe pour accomplir cela ... Je devrais ajouter cela à ma réponse.
Thomas Owens
1
Cela coûtera probablement plus cher que l'approche asList (). Contains (), alors, je pense. Sauf si vous devez le faire très souvent (mais si c'est juste une liste statique de valeurs qui peut être triée pour commencer, pour être juste).
Joey
Vrai. Il y a beaucoup de variables qui seraient les plus efficaces. C'est bien d'avoir des options.
Thomas Owens
Un code qui fait cela ici: stackoverflow.com/a/48242328/9131078
OOBalance
Trier un tableau entier à des fins de recherche coûte cher. Nous pouvons utiliser le même temps CPU pour la recherche de ligne elle-même. Je préfère la recherche binaire sur une collection qui est déjà construite au préalable dans un ordre trié.
arunwithasmile
17

ObStupidAnswer (mais je pense qu'il y a une leçon ici quelque part):

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}
Tom Hawtin - sellerie
la source
1
Le lancement d'exceptions est apparemment lourd, mais ce serait une nouvelle façon de tester une valeur si cela fonctionne. L'inconvénient est que l'énumération doit être définie à l'avance.
James P.
13

En fait, si vous utilisez HashSet <String> comme Tom Hawtin l'a proposé, vous n'avez pas à vous soucier du tri, et votre vitesse est la même qu'avec la recherche binaire sur un tableau pré-trié, probablement encore plus rapide.

Tout dépend de la façon dont votre code est configuré, évidemment, mais d'où je me situe, l'ordre serait:

Sur un tableau non trié :

  1. HashSet
  2. asList
  3. trier et binaire

Sur un tableau trié:

  1. HashSet
  2. Binaire
  3. asList

Donc de toute façon, HashSet pour la victoire.

ne pas
la source
2
L'appartenance à HashSet doit être O (1) et la recherche binaire sur une collection triée est O (log n).
Skylar Saveland
11

Si vous disposez de la bibliothèque de collections Google, la réponse de Tom peut être simplifiée en utilisant ImmutableSet (http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableSet.html)

Cela supprime vraiment beaucoup d'encombrement de l'initialisation proposée

private static final Set<String> VALUES =  ImmutableSet.of("AB","BC","CD","AE");
jhodges
la source
10

Une solution possible:

import java.util.Arrays;
import java.util.List;

public class ArrayContainsElement {
  public static final List<String> VALUES = Arrays.asList("AB", "BC", "CD", "AE");

  public static void main(String args[]) {

      if (VALUES.contains("AB")) {
          System.out.println("Contains");
      } else {
          System.out.println("Not contains");
      }
  }
}
Christian Giménez
la source
8

Les développeurs font souvent:

Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);

Le code ci-dessus fonctionne, mais il n'est pas nécessaire de convertir une liste à définir en premier. La conversion d'une liste en un ensemble nécessite du temps supplémentaire. Cela peut être aussi simple que:

Arrays.asList(arr).contains(targetValue);

ou

   for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }

return false;

Le premier est plus lisible que le second.

Jawad Zeb
la source
7

L'utilisation d'une boucle simple est le moyen le plus efficace de le faire.

boolean useLoop(String[] arr, String targetValue) {
    for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }
    return false;
}

Courtoisie de Programcreek

Ryan
la source
Cela lèvera une exception de pointeur null si le tableau contient une référence null avant la valeur cible.
Samuel Edwin Ward
1
l'instruction if doit être: if (targetValue.equals (s)) car String equals a un vérificateur instanceof.
TheArchon
utilisez Objects.equals (obj1, obj2) à la place pour être sûr de null.
trilogie
7

En Java 8, utilisez Streams.

List<String> myList =
Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList
.stream()
.filter(s -> s.startsWith("c"))
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);
Basheer brillant
la source
7
Y a-t-il des avantages à cette approche?
Johannes Stadler
1
Cela ne répond pas à la question.
Florian F
5
  1. Pour les tableaux de longueur limitée, utilisez ce qui suit (comme indiqué par camickr ). Ceci est lent pour les vérifications répétées, en particulier pour les tableaux plus longs (recherche linéaire).

     Arrays.asList(...).contains(...)
  2. Pour des performances rapides si vous effectuez plusieurs vérifications par rapport à un ensemble d'éléments plus important

    • Un tableau n'est pas la bonne structure. Utilisez a TreeSetet ajoutez-y chaque élément. Il trie les éléments et dispose d'une exist()méthode rapide (recherche binaire).

    • Si les éléments implémentent Comparableet que vous voulezTreeSet trier en conséquence:

      ElementClass.compareTo()La méthode doit être compatible avec ElementClass.equals(): voir Triades ne se présentant pas pour se battre? (Jeu Java manquant un élément)

      TreeSet myElements = new TreeSet();
      
      // Do this for each element (implementing *Comparable*)
      myElements.add(nextElement);
      
      // *Alternatively*, if an array is forceably provided from other code:
      myElements.addAll(Arrays.asList(myArray));
    • Sinon, utilisez le vôtre Comparator:

      class MyComparator implements Comparator<ElementClass> {
           int compareTo(ElementClass element1; ElementClass element2) {
                // Your comparison of elements
                // Should be consistent with object equality
           }
      
           boolean equals(Object otherComparator) {
                // Your equality of comparators
           }
      }
      
      
      // construct TreeSet with the comparator
      TreeSet myElements = new TreeSet(new MyComparator());
      
      // Do this for each element (implementing *Comparable*)
      myElements.add(nextElement);
    • Le gain: vérifiez l'existence d'un élément:

      // Fast binary search through sorted elements (performance ~ log(size)):
      boolean containsElement = myElements.exists(someElement);
Glen Best
la source
4
Pourquoi s'embêter TreeSet? HashSetest plus rapide (O (1)) et ne nécessite pas de commande.
Sean Owen
4

Essaye ça:

ArrayList<Integer> arrlist = new ArrayList<Integer>(8);

// use add() method to add elements in the list
arrlist.add(20);
arrlist.add(25);
arrlist.add(10);
arrlist.add(15);

boolean retval = arrlist.contains(10);
if (retval == true) {
    System.out.println("10 is contained in the list");
}
else {
    System.out.println("10 is not contained in the list");
}
Mr.G
la source
4

Utilisez ce qui suit (la contains()méthode se trouve ArrayUtils.in()dans ce code):

ObjectUtils.java

public class ObjectUtils{

    /**
     * A null safe method to detect if two objects are equal.
     * @param object1
     * @param object2
     * @return true if either both objects are null, or equal, else returns false.
     */
    public static boolean equals(Object object1, Object object2){
        return object1==null ? object2==null : object1.equals(object2);
    }

}

ArrayUtils.java

public class ArrayUtils{

    /**
     * Find the index of of an object is in given array, starting from given inclusive index.
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @param start  The index from where the search must start.
     * @return Index of the given object in the array if it is there, else -1.
     */
    public static <T> int indexOf(final T[] ts, final T t, int start){
        for(int i = start; i < ts.length; ++i)
            if(ObjectUtils.equals(ts[i], t))
                return i;
        return -1;
    }

    /**
     * Find the index of of an object is in given array, starting from 0;
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @return  indexOf(ts, t, 0)
     */
    public static <T> int indexOf(final T[] ts, final T t){
        return indexOf(ts, t, 0);
    }

    /**
     * Detect if the given object is in the given array.
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @return  If indexOf(ts, t) is greater than -1.
     */
    public static <T> boolean in(final T[] ts, final T t){
        return indexOf(ts, t) > -1 ;
    }

}

Comme vous pouvez le voir dans le code ci-dessus, il existe d'autres méthodes utilitaires ObjectUtils.equals()et ArrayUtils.indexOf()qui ont également été utilisées à d'autres endroits.

Abhishek Oza
la source
Je suis très en retard pour participer à cette discussion, mais comme mon approche pour résoudre ce problème, lorsque je l'ai rencontrée il y a quelques années, était un peu différente des autres réponses déjà publiées ici, je publie la solution que j'ai utilisée à l'époque, ici, au cas où quelqu'un le trouverait utile.
Abhishek Oza
3

Vérifiez ça

String[] VALUES = new String[] {"AB","BC","CD","AE"};
String s;

for(int i=0; i< VALUES.length ; i++)
{
    if ( VALUES[i].equals(s) )
    { 
        // do your stuff
    } 
    else{    
        //do your stuff
    }
}
SubbaRao Boddu
la source
1
Cela ne fonctionne pas - il entrera le elsepour chaque élément qui ne correspond pas (donc si vous recherchez "AB" dans ce tableau, il y ira 3 fois, car 3 des valeurs ne sont pas "AB" ").
Bernhard Barker
3

Arrays.asList () -> puis appeler la méthode contains () fonctionnera toujours, mais un algorithme de recherche est bien meilleur car vous n'avez pas besoin de créer un wrapper de liste léger autour du tableau, ce que fait Arrays.asList () .

public boolean findString(String[] strings, String desired){
   for (String str : strings){
       if (desired.equals(str)) {
           return true;
       }
   }
   return false; //if we get here… there is no desired String, return false.
}
TheArchon
la source
Arrays.asListn'est pas O (n). C'est juste un emballage léger. Jetez un oeil à la mise en œuvre.
Patrick Parker
3

Si vous ne voulez pas qu'il soit sensible à la casse

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);
Akhil babu K
la source
2

Utilisation Array.BinarySearch(array,obj) pour trouver l'objet donné dans le tableau ou non.

Exemple:

if (Array.BinarySearch(str, i) > -1)`  true --exists

false - n'existe pas

Vengeur
la source
4
Array.BinarySearchet Array.FindIndexsont des méthodes .NET et n'existent pas en Java.
ataylor
@ataylor, il y a Arrays.binarySearch en java. Mais vous avez raison, aucun Arrays.findIndex
mente
Il convient de noter:The array must be sorted prior to making this call. If it is not sorted, the results are undefined.
Dorian Gray
1

Créez un booléen initialement défini sur false. Exécutez une boucle pour vérifier chaque valeur du tableau et comparer à la valeur que vous comparez. Si vous obtenez un match, définissez booléen sur true et arrêtez la boucle. Affirmez ensuite que le booléen est vrai.

mandy1339
la source
1

Essayez d'utiliser la méthode de test des prédicats Java 8

En voici un exemple complet.

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Test {
 public static final List<String> VALUES = Arrays.asList("AA", "AB", "BC", "CD", "AE");

 public static void main(String args[]) {
  Predicate<String> containsLetterA = VALUES -> VALUES.contains("AB");
  for (String i : VALUES) {

   System.out.println(containsLetterA.test(i));
  } 
 }
}

http://mytechnologythought.blogspot.com/2019/10/java-8-predicate-test-method-example.html

https://github.com/VipulGulhane1/java8/blob/master/Test.java

Vipul Gulhane
la source
0

l'utilisation d'un Spliterator empêche la génération inutile d'un List

boolean found = false;  // class variable

String search = "AB";
Spliterator<String> spl = Arrays.spliterator( VALUES, 0, VALUES.length );
while( (! found) && spl.tryAdvance(o -> found = o.equals( search )) );

found == truesi searchest contenu dans le tableau


cela fait le travail pour les tableaux de primitives

public static final int[] VALUES = new int[] {1, 2, 3, 4};
boolean found = false;  // class variable

int search = 2;
Spliterator<Integer> spl = Arrays.spliterator( VALUES, 0, VALUES.length );
Kaplan
la source
0

Comme je traite avec Java de bas niveau en utilisant les types primitifs octet et octet [], le meilleur que j'ai obtenu jusqu'à présent est de bytes-java https://github.com/patrickfav/bytes-java semble un bon travail

truthadjustr
la source
-2

Vous pouvez le vérifier par deux méthodes

A) En convertissant le tableau en chaîne, puis vérifiez la chaîne requise par la méthode .contains

 String a=Arrays.toString(VALUES);
    System.out.println(a.contains("AB"));
    System.out.println(a.contains("BC"));
    System.out.println(a.contains("CD"));
    System.out.println(a.contains("AE"));

B) c'est une méthode plus efficace

 Scanner s=new Scanner(System.in);


   String u=s.next();
   boolean d=true;
    for(int i=0;i<VAL.length;i++)
    {
        if(VAL[i].equals(u)==d)
            System.out.println(VAL[i] +" "+u+VAL[i].equals(u));  

    }
Syed Salman Hassan
la source
1
La conversion de chaîne est absurdement inefficace et la solution est incorrecte, par exemple contient (",") retournera vrai.
Atuos