Hoe bepaal ik of een array een bepaalde waarde in Java bevat?

Ik heb een String[]met waarden als volgt:

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

Gegeven String s, is er een goede manier om te testen of VALUESsbevat?

Antwoord 1, autoriteit 100%

Arrays.asList(yourArray).contains(yourValue)

Waarschuwing: dit werkt niet voor arrays van primitieven (zie de opmerkingen).

Sinds java-8je kunt nu Streams gebruiken.

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

Om te controleren of een array van int, doubleof longeen waarde bevat, gebruikt u IntStream, DoubleStreamof LongStreamrespectievelijk.

Voorbeeld

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

Antwoord 2, autoriteit 13%

Beknopte update voor Java SE 9

Referentie-arrays zijn slecht. Voor dit geval zijn we op zoek naar een set. Sinds Java SE 9 hebben we Set.of.

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

“Gezien String s, is er een goede manier om te testen of VALUES s bevat?”

VALUES.contains(s)

O(1).

Het juiste type, onveranderlijk, O(1)en beknopt. Prachtig.*

Originele antwoorddetails

Gewoon om de code te wissen om mee te beginnen. We hebben (gecorrigeerd):

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

Dit is een veranderlijke static waarvan FindBugs je zal vertellen dat het erg ondeugend is. Wijzig de statica niet en sta niet toe dat andere code dit ook doet. Het veld moet minimaal privé zijn:

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

(Let op, u kunt de new String[];bit daadwerkelijk laten vallen.)

Referentie-arrays zijn nog steeds slecht en we willen een set:

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

(Paranoïde mensen, zoals ikzelf, voelen zich misschien meer op hun gemak als dit was verpakt in Collections.unmodifiableSet– het zou dan zelfs openbaar kunnen worden gemaakt.)

(*Om een beetje meer op merk te zijn, mist de collecties-API naar verwachting nog steeds onveranderlijke verzamelingstypen en de syntaxis is nog steeds veel te uitgebreid, naar mijn smaak.)

Antwoord 3, autoriteit 7%

U kunt ArrayUtils.containsgebruiken van Apache Commons Lang

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

Merk op dat deze methode falseretourneert als de doorgegeven array nullis.

Er zijn ook methoden beschikbaar voor allerlei soorten primitieve arrays.

Voorbeeld:

String[] fieldsToInclude = { "id", "name", "location" };
if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}

Antwoord 4, autoriteit 5%

Implementeer het gewoon met de hand:

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

Verbetering:

De v != nullvoorwaarde is constant binnen de methode. Het evalueert altijd naar dezelfde Booleaanse waarde tijdens de methodeaanroep. Dus als de invoer arraygroot is, is het efficiënter om deze voorwaarde slechts één keer te evalueren, en we kunnen een vereenvoudigde/snellere voorwaarde gebruiken binnen de for-lus op basis van het resultaat . De verbeterde 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;
}

Antwoord 5, autoriteit 3%

Vier verschillende manieren om te controleren of een Matrix bevat een waarde

1. Gebruik List:

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

2. Gebruik Set:

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

3. Een eenvoudige lus gebruiken:

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

4. Arrays.binarySearch()gebruiken:

   De onderstaande code is onjuist, deze wordt hier voor de volledigheid vermeld. binarySearch()kan ALLEEN worden gebruikt op gesorteerde arrays.U zult hieronder zien dat het resultaat raar is. Dit is de beste optie als de array is gesorteerd.

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

Snel voorbeeld:

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

Antwoord 6, autoriteit 2%

Als de array niet is gesorteerd, moet je alles herhalen en voor elk een aanroep doen naar gelijken.

Als de array is gesorteerd, kun je een binaire zoekopdracht uitvoeren, er is er een in de Arraysklasse.

Als je veel lidmaatschapscontroles gaat doen, wil je in het algemeen alles in een set opslaan, niet in een array.

Antwoord 7, autoriteit 2%

Voor wat het waard is, ik heb een test gedaan waarin ik de drie suggesties voor snelheid vergeleek. Ik genereerde willekeurige gehele getallen, converteerde ze naar een String en voegde ze toe aan een array. Ik zocht toen naar het hoogst mogelijke getal/tekenreeks, wat een worstcasescenario zou zijn voor de asList().contains().

Bij gebruik van een arraygrootte van 10K waren de resultaten:

Sort & Search   : 15
Binary Search   : 0
asList.contains : 0

Bij gebruik van een array van 100K waren de resultaten:

Sort & Search   : 156
Binary Search   : 0
asList.contains : 32

Dus als de array in gesorteerde volgorde is gemaakt, is de binaire zoekactie het snelst, anders zou de asList().containsde juiste keuze zijn. Als je veel zoekopdrachten hebt, kan het de moeite waard zijn om de array te sorteren, zodat je de binaire zoekopdracht kunt gebruiken. Het hangt allemaal af van uw toepassing.

Ik denk dat dit de resultaten zijn die de meeste mensen zouden verwachten. Hier is de 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));
    }
}

Antwoord 8

In plaats van ook de snelle array-initialisatiesyntaxis te gebruiken, kunt u deze direct als een lijst initialiseren op een vergelijkbare manier met behulp van de Arrays.asList-methode, bijvoorbeeld:

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

Dan kun je doen (zoals hierboven):

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

Antwoord 9

Met Java 8 kun je een stream maken en controleren of er items in de stream overeenkomen met "s":

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

Of als een generieke methode:

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

Antwoord 10

U kunt de Arrays-klassegebruiken om een binaire zoekopdracht naar de waarde uit te voeren. Als uw array niet is gesorteerd, moet u de sorteerfuncties in dezelfde klasse gebruiken om de array te sorteren en er vervolgens doorheen te zoeken.

Antwoord 11

ObStupidAnswer (maar ik denk dat hier ergens een les in zit):

enum Values {
    AB, BC, CD, AE
}
try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}

Antwoord 12

Eigenlijk, als u HashSet<String> zoals Tom Hawtin voorstelde, hoef je je geen zorgen te maken over sorteren, en je snelheid is hetzelfde als bij binair zoeken op een voorgesorteerde array, waarschijnlijk zelfs sneller.

Het hangt natuurlijk allemaal af van hoe je code is ingesteld, maar van waar ik sta, zou de volgorde zijn:

Op een ongesorteerdearray:

1. HashSet
2. alsLijst
3. sorteren & binair

Op een gesorteerde array:

1. HashSet
2. Binair
3. alsLijst

Dus hoe dan ook, HashSet voor de overwinning.

Antwoord 13

Als je de Google Collections-bibliotheek hebt, kan het antwoord van Tom aanzienlijk worden vereenvoudigd door ImmutableSet te gebruiken (http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableSet. html)

Dit verwijdert echt een hoop rommel van de voorgestelde initialisatie

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

Antwoord 14

Een mogelijke oplossing:

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

Antwoord 15

Ontwikkelaars doen vaak:

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

De bovenstaande code werkt, maar het is niet nodig om een lijst eerst te converteren naar set. Het omzetten van een lijst naar een set kost extra tijd. Het kan zo simpel zijn als:

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

of

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

De eerste is beter leesbaar dan de tweede.

Antwoord 16

Gebruik in Java 8Streams.

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

Antwoord 17

Het gebruik van een eenvoudige lus is de meest efficiënte manier om dit te doen.

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

Met dank aan Programcreek

Antwoord 18

1. Gebruik voor arrays van beperkte lengte het volgende (zoals gegeven door camickr). Dit is traag voor herhaalde controles, vooral voor langere arrays (lineair zoeken).

   Arrays.asList(...).contains(...)
   

2. Voor snelle prestaties als u herhaaldelijk vergelijkt met een grotere set elementen

   • Een array heeft de verkeerde structuur. Gebruik een TreeSeten voeg er elk element aan toe. Het sorteert elementen en heeft een snelle exist()methode (binair zoeken).

   • Als de elementen Comparable& je wilt dat de TreeSetdienovereenkomstig wordt gesorteerd:

     De methode

     ElementClass.compareTo()moet compatibel zijn met ElementClass.equals(): zie Triaden komen niet opdagen om te vechten? (Java-set mist een item)

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

   • Gebruik anders uw eigen 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);
     

   • De uitbetaling: controleer het bestaan van een element:

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

Antwoord 19

Gebruik het volgende (de methode contains()is ArrayUtils.in()in deze 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;
    }
}

Zoals je in de bovenstaande code kunt zien, zijn er andere hulpprogramma’s ObjectUtils.equals()en ArrayUtils.indexOf(), die op andere plaatsen werden gebruikt ook.

Antwoord 20

Probeer dit:

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

Antwoord 21

Arrays.asList() -> dan zal het aanroepen van de methode contain() altijd werken, maar een zoekalgoritme is veel beter omdat je geen lichtgewicht lijstwikkel rond de array hoeft te maken, wat Arrays.asList() doet.

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

Antwoord 22

Als u niet wilt dat het hoofdlettergevoelig is

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);

Antwoord 23

Controleer dit

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

Antwoord 24

Gebruik Array.BinarySearch(array,obj)om het gegeven object al dan niet in array te vinden.

Voorbeeld:

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

false –bestaat niet

Antwoord 25

de kortste oplossing
de arrayVALUESkan duplicaten bevatten
sinds Java 9

List.of(VALUES).contains(s);

Antwoord 26

Maak een boolean die aanvankelijk is ingesteld op false. Voer een lus uit om elke waarde in de array te controleren en te vergelijken met de waarde waarmee u controleert. Als je ooit een overeenkomst krijgt, stel dan boolean in op true en stop de looping. Beweer dan dat de boolean waar is.

Antwoord 27

Omdat ik te maken heb met Java op laag niveau met behulp van de primitieve typen byte en byte[], is de beste die ik tot nu toe heb gekregen van bytes-javahttps://github.com/patrickfav/bytes-javalijkt een mooi stukje werk

Antwoord 28

Probeer Java 8 predikaattestmethode te gebruiken

Hier is een volledig voorbeeld ervan.

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-predicaat-test-methode-voorbeeld.html

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

Antwoord 29

Je kunt het op twee manieren controleren

A) Door de array om te zetten in een tekenreeks en vervolgens de vereiste tekenreeks te controleren met de .contains-methode

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) Dit is een efficiëntere methode

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