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

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

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

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

1910
задан Mike Sickler 15 июля '09 в 3:03
источник поделиться
27 ответов
Arrays.asList(yourArray).contains(yourValue)

Предупреждение: это не работает для массивов примитивов (см. Комментарии).


Начиная с вы можете использовать Streams.

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

Чтобы проверить, является ли массив int, double или long содержит значение используется IntStream, DoubleStream или LongStream соответственно.

пример

int[] a = {1,2,3,4};
boolean contains = IntStream.of(a).anyMatch(x -> x == 4);
2479
ответ дан camickr 15 июля '09 в 3:04
источник поделиться

Просто, чтобы очистить код до начала. У нас (исправлено):

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

Это изменчивый статик, который FindBugs скажет вам, очень непослушный. Он должен быть закрытым:

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

(Обратите внимание: вы действительно можете удалить бит new String[];.)

Итак, ссылочные массивы плохие, и в частности здесь нам нужен набор:

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

(Параноидальные люди, такие как я, могут чувствовать себя более непринужденно, если это было завернуто в Collections.unmodifiableSet - его можно даже обнародовать).

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

VALUES.contains(s)

О (1).

312
ответ дан Tom Hawtin - tackline 15 июля '09 в 4:13
источник поделиться

Вы можете использовать ArrayUtils.contains из Apache Commons Lang

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

Обратите внимание, что этот метод возвращает false, если переданный массив null.

Существуют также методы, доступные для примитивных массивов всех типов.

Пример:

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

if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}
173
ответ дан Intracer 31 мая '11 в 16:17
источник поделиться

Я удивлен, что никто не предложил просто реализовать его вручную:

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

Улучшение:

Условие v != null является постоянным внутри метода, оно всегда вычисляет одно и то же логическое значение во время вызова метода. Поэтому, если вход array велик, эффективнее оценивать это условие только один раз, и мы можем использовать упрощенное/более быстрое условие внутри цикла for на основе результата. Улучшенный метод contains():

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;
}
145
ответ дан icza 28 сент. '12 в 10:45
источник поделиться

Если массив не отсортирован, вам придется перебирать все и делать вызов равным для каждого.

Если массив отсортирован, вы можете выполнить двоичный поиск, там один в классе Arrays.

Вообще говоря, если вы собираетесь выполнять много проверок членства, вы можете захотеть сохранить все в наборе, а не в массиве.

65
ответ дан Uri 15 июля '09 в 3:05
источник поделиться

Четыре разных способа проверки, если массив содержит значение

1) Использование списка:

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

2) Использование Set:

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

3) Используя простой цикл:

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

4) Использование Arrays.binarySearch():

Код ниже неверен, он указан здесь для полноты. binarySearch() может ТОЛЬКО использоваться на отсортированных массивах. Вы увидите, что результат ниже. Это лучший вариант при сортировке массива.

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

Быстрый пример:

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
61
ответ дан Sireesh Yarlagadda 07 мая '14 в 22:14
источник поделиться

Для чего стоит тест, сравнивающий 3 предложения по скорости. Я генерировал случайные целые числа, преобразовывал их в String и добавлял их в массив. Затем я искал максимально возможное число/строку, что было бы наихудшим сценарием для asList(). Contains().

При использовании размера массива 10K результаты, где:

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

При использовании массива 100K результаты:

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

Итак, если массив создан в отсортированном порядке, бинарный поиск является самым быстрым, в противном случае asList() будет содержать путь. Если у вас много поисков, может быть целесообразно отсортировать массив, чтобы вы могли использовать двоичный поиск. Все зависит от вашего приложения.

Я бы подумал, что это те результаты, которые ожидали большинство людей. Вот тестовый код:

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));
    }
}
47
ответ дан camickr 15 июля '09 в 4:28
источник поделиться

С Java 8 вы можете создать поток и проверить, соответствуют ли записи в потоке "s":

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

Или как общий метод:

public static <T> boolean arrayContains(T[] array, T value) {
    return Arrays.stream(array).anyMatch(value::equals);
}
30
ответ дан assylias 13 марта '14 в 17:53
источник поделиться

Вместо того, чтобы использовать синтаксис инициализации быстрого массива, вы можете просто инициализировать его как список сразу же, используя метод Arrays.asList, например:

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

Затем вы можете сделать (например, выше): STRINGS.contains("the string you want to find");

29
ответ дан Mark Rhodes 20 янв. '11 в 16:58
источник поделиться

Вы можете использовать класс Arrays для выполнения двоичного поиска значения. Если ваш массив не отсортирован, вам придется использовать функции сортировки в том же классе для сортировки массива, а затем выполнить поиск через него.

23
ответ дан Thomas Owens 15 июля '09 в 3:05
источник поделиться

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

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}
15
ответ дан Tom Hawtin - tackline 15 июля '09 в 4:18
источник поделиться

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

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

В массиве Unsorted:

  • HashSet
  • asList
  • сортировка и двоичный

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

  • HashSet
  • Binary
  • asList

Так или иначе, HashSet ftw

11
ответ дан not 11 июня '10 в 5:37
источник поделиться

Если у вас есть библиотека коллекций google, ответ Tom можно упростить, используя 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");
9
ответ дан jhodges 19 сент. '12 в 17:13
источник поделиться

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

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");
      }
  }
}
7
ответ дан Christian Giménez 15 дек. '14 в 0:49
источник поделиться

В 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);
6
ответ дан Shineed Basheer 28 апр. '15 в 9:40
источник поделиться

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

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;

Первая из них более читаема, чем вторая.

6
ответ дан Xar E Ahmer 25 июня '14 в 10:24
источник поделиться

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

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

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

4
ответ дан Ryan 07 апр. '14 в 22:53
источник поделиться
  • Для массивов ограниченной длины используйте следующее (как указано camickr). Это медленно для повторных проверок, особенно для более длинных массивов (линейный поиск).

     Arrays.asList(...).contains(...)
    
  • Для быстрой работы, если вы неоднократно проверяете более широкий набор элементов

    • Массив - неправильная структура. Используйте 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);
      
3
ответ дан Glen Best 20 мая '13 в 10:34
источник поделиться

Arrays.asList() ->, тогда вызов метода contains() всегда будет работать, но алгоритм поиска намного лучше, поскольку вам не нужно создавать упрощенную оболочку списка вокруг массива, что и делает 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.
}
2
ответ дан WIll 30 апр. '15 в 5:57
источник поделиться

Попробуйте следующее:

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");
}
1
ответ дан Mr.G 07 дек. '13 в 7:19
источник поделиться

Проверьте это

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
    }
}
1
ответ дан SubbaRao Boddu 05 июня '14 в 13:19
источник поделиться

Это может быть просто:

String[] VALUE = new String[] {"AB","BC","CD","AE"};
Arrays.asList(VALUE).contains(s);
1
ответ дан Aaron Chen 27 сент. '17 в 6:55
источник поделиться

Если вы не хотите, чтобы это было чувствительно к регистру

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);
1
ответ дан Akhil babu K 21 сент. '18 в 20:16
источник поделиться

Я очень опаздываю, чтобы присоединиться к этой дискуссии, но поскольку мой подход к решению этой проблемы, когда я столкнулся с ней несколько лет назад, немного отличался от других ответов, уже размещенных здесь, я публикую это решение, которое я использовал в на этот раз, здесь, в случае, если кто-то найдет это полезным: (< <20 > в 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(), которые также использовались в других местах.

1
ответ дан Abhishek Oza 23 июля '14 в 16:25
источник поделиться

Используйте Array.BinarySearch(array,obj) для поиска данного объекта в массиве или нет. Пример:

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

false - не существует

1
ответ дан Avenger 30 мая '13 в 9:59
источник поделиться

Вот мой простой код, используя класс Arrays из пакета util. Это можно сделать многими другими способами, но, поставив вопрос, этот подход пришел мне на ум.

String a[] = {"abc","xyz","pqr"};
System.out.println(Arrays.asList(a).contains("abc")); //will return true
System.out.println(Arrays.asList(a).contains("abcd")); // will return false
0
ответ дан Debjyoti Pandit 03 окт. '18 в 16:17
источник поделиться

Создайте логическое значение, первоначально заданное как false. Запустите цикл, чтобы проверить каждое значение в массиве и сравнить с значением, которое вы проверяете. Если вы когда-либо получаете совпадение, установите boolean в true и остановите цикл. Тогда утвердим, что логическое значение истинно.

-1
ответ дан mandy1339 17 мая '18 в 22:37
источник поделиться

Другие вопросы по меткам