Wie kann ich in Java feststellen, ob ein Array einen bestimmten Wert enthält?

Question

Ich habe eine String[] mit Werten wie diesen:

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

Gegeben String s Gibt es eine gute Methode, um zu testen, ob VALUES enthält s ?

Answer 1

Arrays.asList(yourArray).contains(yourValue)

Achtung: Dies funktioniert nicht für Arrays von Primitiven (siehe Kommentare).

---

Desde java-8 können Sie jetzt Streams verwenden.

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

Um zu prüfen, ob ein Array von int , double o long enthält einen Wert Verwendung IntStream , DoubleStream o LongStream beziehungsweise.

Beispiel

int[] a = {1,2,3,4};
boolean contains = IntStream.of(a).anyMatch(x -> x == 4);

Answer 2

Kurzes Update für Java SE 9

Referenz-Arrays sind schlecht. In diesem Fall suchen wir eine Menge. Seit Java SE 9 haben wir Set.of .

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

"Gibt es bei einer Zeichenkette s eine gute Möglichkeit zu prüfen, ob VALUES s enthält?"

VALUES.contains(s)

O(1).

Le site richtige Art , unveränderlich , O(1) y kurz und bündig . Schön.*

Details der Originalantwort

Nur um den Code zunächst einmal zu klären. Wir haben (korrigiert):

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

Dies ist ein veränderbares statisches Element, das FindBugs als sehr unanständig bezeichnen wird. Ändern Sie keine Statics und erlauben Sie anderen Code nicht, dies ebenfalls zu tun. Als absolutes Minimum sollte das Feld privat sein:

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

(Hinweis: Sie können die new String[]; bit.)

Referenz-Arrays sind immer noch schlecht, und wir wollen einen Satz:

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

(Paranoide Menschen, wie ich selbst, würden sich vielleicht wohler fühlen, wenn dies in Collections.unmodifiableSet - sie könnte dann sogar veröffentlicht werden).

(*Um ein wenig mehr auf der Höhe der Zeit zu sein, die Sammlungen API ist vorhersehbar immer noch fehlen unveränderliche Sammlungstypen und die Syntax ist immer noch viel zu langatmig, für meinen Geschmack).

Answer 3

Sie können verwenden ArrayUtils.contains de Apache Commons Lang

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

Beachten Sie, dass diese Methode Folgendes zurückgibt false wenn das übergebene Array null .

Es gibt auch Methoden für primitive Arrays aller Art.

Ejemplo:

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

if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}

Answer 4

Führen Sie es einfach von Hand aus:

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;
}

Verbesserung:

Le site v != null Bedingung innerhalb der Methode konstant ist. Sie wird während des Methodenaufrufs immer auf denselben booleschen Wert ausgewertet. Wenn also die Eingabe array groß ist, ist es effizienter, diese Bedingung nur einmal auszuwerten, und wir können eine vereinfachte/schnellere Bedingung innerhalb der for Schleife auf der Grundlage des Ergebnisses. Die verbesserte contains() Methode:

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;
}

Answer 5

Vier verschiedene Möglichkeiten zu prüfen, ob ein Array einen Wert enthält

1. Verwendung von List :

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

2. Verwendung von Set :

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

3. Verwendung einer einfachen Schleife:

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

4. Verwendung von Arrays.binarySearch() :

   Der unten stehende Code ist falsch, er wird hier nur der Vollständigkeit halber aufgeführt. binarySearch() kann NUR für sortierte Arrays verwendet werden. Das Ergebnis finden Sie weiter unten. Dies ist die beste Option, wenn das Feld sortiert ist.

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

Schnelles Beispiel:

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