Как определить, содержит ли массив определенное значение в Java?

Question

У меня есть String[] со значениями, такими как:

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

Учитывая String s, есть ли хороший способ проверить, содержит ли VALUES s?

Answer 1

ObStupidAnswer (но я думаю, что где-то здесь есть урок):

enum Values {
    AB, BC, CD, AE
}

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

Answer 2

На самом деле, если вы используете HashSet , как предложил Том Хотин, вам не нужно беспокоиться о сортировке, и ваша скорость такая же, как при бинарном поиске в предварительно отсортированном массиве, возможно, даже быстрее.

Очевидно, все зависит от того, как настроен ваш код, но с того места, где я стою, порядок будет:

В несортированном массиве:

1. HashSet
2. asList
3. сортировка и двоичные файлы

В отсортированном массиве:

1. HashSet
2. Binary
3. asList

Так или иначе, HashSet для победы.

Answer 3

Если у вас есть библиотека коллекций Google, ответ Тома может быть значительно упрощен с помощью ImmutableSet (http://google -collections.googlecode.com / svn / trunk / javadoc / com / google / common / collect / ImmutableSet.html)

Это действительно удаляет много беспорядка из предложенной инициализации

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

Answer 4

Одно из возможных решений:

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

Answer 5

Разработчики часто делают:

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

Приведенный выше код работает, но нет необходимости преобразовывать список для установки в первую очередь. Преобразование списка в набор требует дополнительного времени. Это может так просто, как:

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

или

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

return false;

Первый более читабелен, чем второй.

Answer 6

Использование простого цикла является наиболее эффективным способом сделать это.

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

Предоставлено Programcreek

Answer 7

В Java 8 использовать потоки.

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

Answer 8

1. Для массивов ограниченной длины используйте следующее (как указано camickr ). Это медленно для повторных проверок, особенно для более длинных массивов (линейный поиск).

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

2. Для быстрой работы, если вы неоднократно проверяете по большому набору элементов

   • Массив неправильной структуры. Используйте TreeSet и добавьте каждый элемент к нему. Он сортирует элементы и имеет быстрый метод exist() (бинарный поиск).

   • Если элементы реализуют Comparable и вы хотите, чтобы TreeSet сортировалось соответственно:

     ElementClass.compareTo() метод должен быть совместим с ElementClass.equals(): см. Триады не появляются, чтобы сражаться? (Java Set отсутствует элемент)

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

   • В противном случае используйте свой собственный 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);
     

   • Выплата: проверьте наличие некоторого элемента:

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

Answer 9

Попробуйте это:

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

Answer 10

Используйте следующее (метод contains() в этом коде ArrayUtils.in()):

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

}

Как видно из приведенного выше кода, существуют другие служебные методы ObjectUtils.equals() и ArrayUtils.indexOf(), которые также использовались в других местах.