it-swarm.com.de

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

Ich habe einen String[] mit folgenden Werten:

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

Gibt es bei String s eine gute Möglichkeit zu testen, ob VALUESs enthält?

2151
Mike Sickler
Arrays.asList(yourArray).contains(yourValue)

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


Seit Java-8 können Sie jetzt Streams verwenden.

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

Um zu überprüfen, ob ein Array von int, double oder long einen Wert enthält, verwenden Sie IntStream, DoubleStream bzw. LongStream.

Beispiel

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

Nur um den Code zu löschen. Wir haben (korrigiert):

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

Dies ist eine veränderbare Statik, von der FindBugs Ihnen mitteilt, dass sie sehr ungezogen ist. Es sollte privat sein:

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

(Beachten Sie, dass Sie das new String[]; -Bit tatsächlich löschen können.)

Also, Referenz-Arrays sind schlecht, und im Besonderen wollen wir hier eine Menge:

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

(Paranoide Menschen, wie ich, könnten sich wohler fühlen, wenn dies in Collections.unmodifiableSet verpackt wäre - es könnte sogar veröffentlicht werden.)

Msgstr "Gibt es eine gute Möglichkeit zu testen, ob VALUES s enthält?"

VALUES.contains(s)

O (1).

pdate: Seit Java SE 9 haben wir Set.of.

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

Der richtige Typ, nveränderlich, O (1) und prägnant. Schön.

(Um ein bisschen mehr über die Marke zu erfahren, fehlen der Collections-API vorhersehbar immer noch unveränderliche Collection-Typen, und die Syntax ist für meinen Geschmack immer noch viel zu ausführlich.)

342

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

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

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

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

Beispiel:

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

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

Einfach von Hand umsetzen:

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:

Die v != null -Bedingung ist innerhalb der Methode konstant. Während des Methodenaufrufs wird immer derselbe Boolesche 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 basierend auf dem Ergebnis verwenden. 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;
}
154
icza

Wenn das Array nicht sortiert ist, müssen Sie über alles iterieren und jeweils equals aufrufen.

Wenn das Array sortiert ist, können Sie eine binäre Suche durchführen. Die Klasse Arrays enthält eine solche.

Im Allgemeinen möchten Sie, wenn Sie viele Mitgliedschaftsüberprüfungen durchführen, möglicherweise alles in einem Set und nicht in einem Array speichern.

70
Uri

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

1) Mit Liste:

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

2) Verwenden von Set:

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

3) Verwenden einer einfachen Schleife:

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

4) Verwenden von Arrays.binarySearch ():

Der folgende Code ist falsch. Der Vollständigkeit halber wird er hier aufgeführt. binarySearch () kann NUR für sortierte Arrays verwendet werden. Sie werden feststellen, dass das Ergebnis unten seltsam ist. Dies ist die beste Option, wenn das Array sortiert ist.

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

Kurzes 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
68

Für das, was es wert ist, führte ich einen Test durch, der die 3 Vorschläge für Geschwindigkeit vergleicht. Ich habe zufällige Ganzzahlen generiert, diese in einen String konvertiert und einem Array hinzugefügt. Ich habe dann nach der höchstmöglichen Zahl/Zeichenfolge gesucht, was für das asList().contains() ein Worst-Case-Szenario wäre.

Bei Verwendung einer Array-Größe von 10 KB lauteten die Ergebnisse wie folgt:

 Sortieren & Suchen: 15 
 Binäre Suche: 0 
 AsList.contains: 0 

Bei Verwendung eines 100K-Arrays wurden folgende Ergebnisse erzielt:

 Sortieren & Suchen: 156 
 Binäre Suche: 0 
 AsList.contains: 32 

Wenn also das Array in sortierter Reihenfolge erstellt wird, ist die binäre Suche die schnellste, andernfalls wäre asList().contains der richtige Weg. Wenn Sie viele Suchanfragen haben, lohnt es sich möglicherweise, das Array zu sortieren, damit Sie die binäre Suche verwenden können. Es hängt alles von Ihrer Anwendung ab.

Ich würde denken, das sind die Ergebnisse, die die meisten Leute erwarten würden. Hier ist der Testcode:

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));
    }
}
48
camickr

Mit Java 8 können Sie einen Stream erstellen und prüfen, ob Einträge im Stream mit "s" übereinstimmen:

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

Oder als generische Methode:

public static <T> boolean arrayContains(T[] array, T value) {
    return Arrays.stream(array).anyMatch(value::equals);
}
34
assylias

Anstatt auch die schnelle Array-Initialisierungssyntax zu verwenden, können Sie sie auf ähnliche Weise mit der Arrays.asList-Methode direkt als Liste initialisieren, z.

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

Dann können Sie (wie oben) tun:

STRINGS.contains("the string you want to find");
34
Mark Rhodes

Sie können die Arrays-Klasse verwenden, um eine binäre Suche nach dem Wert durchzuführen. Wenn Ihr Array nicht sortiert ist, müssen Sie die Sortierfunktionen in derselben Klasse verwenden, um das Array zu sortieren, und dann danach suchen.

26
Thomas Owens

ObStupidAnswer (aber ich denke, hier gibt es irgendwo eine Lektion):

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}
18

Wenn Sie HashSet <String> verwenden, wie von Tom Hawtin vorgeschlagen, müssen Sie sich keine Gedanken über das Sortieren machen, und Ihre Geschwindigkeit ist dieselbe wie bei der binären Suche in einem vorsortierten Array, wahrscheinlich sogar noch schneller.

Es hängt natürlich alles davon ab, wie Ihr Code eingerichtet ist, aber von meinem Standpunkt aus würde die Reihenfolge lauten:

In einem nsortierten Array:

  1. HashSet
  2. asList
  3. sortieren & binär

Auf einem sortierten Array:

  1. HashSet
  2. Binär
  3. asList

So oder so, HashSet für den Sieg.

13
not

Wenn Sie über die Google Collections-Bibliothek verfügen, kann Toms Antwort mithilfe von ImmutableSet (http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableSet.html) erheblich vereinfacht werden.

Dies entfernt wirklich viel Unordnung von der vorgeschlagenen Initialisierung

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

Eine mögliche Lösung:

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");
      }
  }
}
10

Entwickler machen oft:

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

Der obige Code funktioniert, es ist jedoch nicht erforderlich, eine Liste so zu konvertieren, dass sie zuerst festgelegt wird. Das Konvertieren einer Liste in ein Set erfordert zusätzliche Zeit. Es kann so einfach sein wie:

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

oder

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

return false;

Der erste ist besser lesbar als der zweite.

8
Xar E Ahmer

In Java 8 Streams verwenden.

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);
7
Shineed Basheer

Die Verwendung einer einfachen Schleife ist der effizienteste Weg, dies zu tun.

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

Mit freundlicher Genehmigung von Programcreek

7
Ryan
  1. Verwenden Sie für Arrays mit begrenzter Länge Folgendes (wie von camickr angegeben). Dies ist bei wiederholten Überprüfungen, insbesondere bei längeren Arrays (lineare Suche), langsam.

     Arrays.asList(...).contains(...)
    
  2. Für eine schnelle Leistung, wenn Sie wiederholt gegen einen größeren Satz von Elementen prüfen

    • Ein Array hat die falsche Struktur. Verwenden Sie ein TreeSet und fügen Sie jedes Element hinzu. Es sortiert Elemente und hat eine schnelle exist() -Methode (binäre Suche).

    • Wenn die Elemente Comparable implementieren und Sie möchten, dass der TreeSet entsprechend sortiert wird:

      ElementClass.compareTo() -Methode muss mit ElementClass.equals() kompatibel sein: siehe Triaden, die nicht zum Kampf erscheinen? (Java-Set, bei dem ein Gegenstand fehlt

      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));
      
    • Andernfalls verwenden Sie Ihren eigenen 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);
      
    • Die Auszahlung: Überprüfen Sie die Existenz eines Elements:

      // Fast binary search through sorted elements (performance ~ log(size)):
      boolean containsElement = myElements.exists(someElement);
      
5
Glen Best

Versuche dies:

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");
}
4
Mr.G

Verwenden Sie Folgendes (die Methode contains() ist ArrayUtils.in() in diesem 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 ;
    }

}

Wie Sie im obigen Code sehen können, gibt es andere Dienstprogrammmethoden ObjectUtils.equals() und ArrayUtils.indexOf(), die auch an anderen Stellen verwendet wurden.

4
Abhishek Oza

Arrays.asList () -> Das Aufrufen der Methode includes () funktioniert immer, aber ein Suchalgorithmus ist viel besser, da Sie keinen einfachen Listenwrapper um das Array erstellen müssen, wie es Arrays.asList () tut .

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.
}
3
WIll

Wenn Sie nicht möchten, dass zwischen Groß- und Kleinschreibung unterschieden wird

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);
3
Akhil babu K

Verwenden Sie Array.BinarySearch(array,obj), um das angegebene Objekt im Array zu finden oder nicht.

Beispiel:

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

false - nicht vorhanden

3
Avenger

Überprüfen Sie dies

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
    }
}
3
SubbaRao Boddu

Erstellen Sie einen Booleschen Wert, der ursprünglich auf false festgelegt war. Führen Sie eine Schleife aus, um jeden Wert im Array zu überprüfen und mit dem Wert zu vergleichen, mit dem Sie prüfen. Wenn Sie jemals eine Übereinstimmung erhalten, setzen Sie den Booleschen Wert auf true und beenden Sie die Schleife. Dann behaupten Sie, dass der Boolesche Wert wahr ist.

0
mandy1339