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

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

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

2588
Mike Sickler 15 Июл 2009 в 04:03
6
Долгий путь, но вы можете использовать цикл for: "for (String s: VALUES) if (s.equals (" MYVALUE ")) return true;
 – 
Zack
15 Июл 2009 в 04:51
3
@ camickr - у меня почти идентичная ситуация с этим: stackoverflow.com/a/223929/12943 Он просто сохраняет получение голосов было просто копией / вставкой из документации Sun. Я предполагаю, что оценка зависит от того, сколько помощи вы предоставили, а не от того, сколько усилий вы приложили к ней - а в основном от того, как быстро вы ее публикуете! Может, мы наткнулись на секрет Джона Скита! Что ж, хороший ответ, +1 для вас.
 – 
Bill K
29 Апр 2013 в 10:50
2
Если вы используете Apache Commons, тогда org.apache.commons.lang.ArrayUtils.contains () сделает это за вас.
 – 
Mr. Boy
13 Ноя 2013 в 01:05
44
Потому что люди, подобные мне, задают вопрос в Google, нажимают на результат SO, видят ваш ответ, тестируют его, он работает, голосуют за ответ и уходят.
 – 
Aequitas
20 Июл 2015 в 05:41
2
Мне очень не хватает простых indexOf и contains в java.util.Arrays, которые содержат простые циклы. Да, вы можете написать их за 1 минуту; но я все равно пошел на StackOverflow, ожидая найти их где-нибудь в JDK.
 – 
tucuxi
1 Май 2020 в 13:38

30 ответов

Лучший ответ
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);
3262
Ray Hulha 8 Окт 2018 в 15:35
106
Мне несколько любопытно, насколько эффективно это работает по сравнению с функциями поиска в классе Arrays по сравнению с итерацией по массиву и использованием функции equals () или == для примитивов.
 – 
Thomas Owens
15 Июл 2009 в 04:06
195
Вы не потеряете много, поскольку asList () возвращает ArrayList, в основе которого лежит массив. Конструктор просто изменит ссылку, так что работы там не так уж и много. И contains () / indexOf () будет выполнять итерацию и использовать equals (). Однако для примитивов лучше писать самому. Для Strings или других классов разница не будет заметна.
 – 
Joey
15 Июл 2009 в 04:09
19
Странно, NetBeans утверждает, что «Arrays.asList (праздники)» для «int [] праздников» возвращает «список », а не «список ». Он просто содержит один единственный элемент. Это означает, что Contains не работает, поскольку в нем всего один элемент; массив int.
 – 
Nyerguds
13 Ноя 2010 в 16:15
65
Ньергудс: действительно, для примитивов это не работает. В java примитивные типы не могут быть общими. asList объявлен как List asList (T ...). Когда вы передаете ему int [], компилятор выводит T = int [], потому что он не может вывести T = int, потому что примитивы не могут быть универсальными.
 – 
CromTheDestroyer
14 Июн 2011 в 20:51
30
Просто примечание, это ArrayList, но не java.util.ArrayList, как вы ожидали, реальный возвращаемый класс: java.util.Arrays.ArrayList<E> определяется как: public class java.util.Arrays {private static class ArrayList<E> ... {}}.
 – 
TWiStErRob
17 Окт 2012 в 13:16

Просто реализуйте это вручную:

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;
}
165
Peter Mortensen 5 Янв 2019 в 12:14
9
Это решение, очевидно, быстрее, потому что принятый ответ превращает массив в список и вызывает метод contains () в этом списке, в то время как мое решение в основном делает то, что делает только contains ().
 – 
icza
10 Окт 2012 в 15:25
10
E == v выполняет очень быструю проверку равенства ссылок. Если в массиве есть такой же объект (такой же по ссылке), он будет найден быстрее. Если это не тот же экземпляр, он все равно может быть таким же, как заявлено методом equals (), это то, что проверяется, если ссылки не совпадают.
 – 
icza
15 Янв 2013 в 12:39
24
Почему эта функция не является частью Java? Неудивительно, что люди говорят, что Java раздута ... посмотрите на все приведенные выше ответы, которые используют кучу библиотек, когда все, что вам нужно, - это цикл for. Дети в наши дни!
 – 
phreakhead
2 Апр 2013 в 23:30
4
Это часть Java, см. Collection.contains(Object)
 – 
Steve Kuo
11 Янв 2014 в 04:37
12
Если вы посмотрите на исходный код Arrays и ArrayList, окажется, что это не обязательно быстрее, чем версия, использующая Arrays.asList(...).contains(...). Накладные расходы на создание ArrayList чрезвычайно малы, а ArrayList.contains() использует более умный цикл (фактически он использует два разных цикла), чем показанный выше (JDK 7).
 – 
Axel
11 Фев 2014 в 11:41

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

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

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

74
Uri 14 Июл 2014 в 19:13
1
Кроме того, как я сказал в своем ответе, если вы используете класс Arrays, вы можете отсортировать массив, а затем выполнить двоичный поиск по только что отсортированному массиву.
 – 
Thomas Owens
15 Июл 2009 в 04:10
1
@ Томас: Я согласен. Или вы можете просто добавить все в TreeSet; такая же сложность. Я бы использовал массивы, если они не меняются (возможно, немного сэкономить место в памяти, поскольку ссылки расположены непрерывно, а строки - нет). Я бы использовал набор, если бы это со временем изменилось.
 – 
Uri
15 Июл 2009 в 04:14

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

При использовании массива размером 10 КБ результаты были:

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

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

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

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

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

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));
    }
}
53
Community 2 Июн 2021 в 08:01
6
Я не понимаю этот код. Вы сортируете «строки» массива и используете один и тот же (отсортированный) массив в обоих вызовах binarySearch. Как это может показать что-либо, кроме оптимизации времени выполнения HotSpot? То же самое и с вызовом asList.contains. Вы создаете список из отсортированного массива, а затем содержит в нем наибольшее значение. Конечно, на это потребуется время. В чем смысл этого теста? Не говоря уже о том, что это неправильно написанный микробенчмарк.
 – 
Erik
30 Май 2013 в 13:16
Кроме того, поскольку двоичный поиск может применяться только к отсортированному набору, сортировка и поиск - единственный возможный способ использования двоичного поиска.
 – 
Erik
30 Май 2013 в 13:18
Сортировка могла уже быть выполнена по ряду других причин, например, она могла быть отсортирована при инициализации и никогда не изменялась. Само по себе время поиска можно использовать. Однако это не совсем удачный пример микробенчмаркинга. Микробенчмарки, как известно, сложно реализовать в Java, и они должны, например, включать выполнение тестового кода, достаточного для оптимизации точки доступа перед запуском фактического теста, не говоря уже о запуске фактического тестового кода чаще, чем ОДИН РАЗ с таймером. Примеры ошибок
 – 
Thor84no
24 Окт 2013 в 16:25
8
Этот тест ошибочен, поскольку он запускает все 3 теста в одном экземпляре JVM. Более поздние тесты могут выиграть от более ранних, разогревающих кеш, JIT и т. Д.
 – 
Steve Kuo
11 Янв 2014 в 04:39
5
Этот тест на самом деле совершенно не связан. Сортировка и поиск - это линейная (n * log (n)) сложность, двоичный поиск - логарифмический, а ArrayUtils.contains - очевидно линейный. Сравнивать эти решения бесполезно, поскольку они находятся в совершенно разных классах сложности.
 – 
dragn
11 Сен 2014 в 17:47

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

  1. Использование List:

    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) {  
        return Arrays.binarySearch(arr, targetValue) >= 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
91
Ivar 17 Июн 2020 в 10:34
5
Ваш пример двоичного поиска должен возвращать> 0;
 – 
Will Sherwood
27 Мар 2015 в 04:33
7
Почему? Я думаю, он должен вернуть a> -1, поскольку 0 означает, что он содержится в заголовке массива.
 – 
mbelow
25 Май 2016 в 18:22
3
Первый вариант с (a >= 0) был правильным, просто проверьте документы, они говорят:« Обратите внимание, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ найден ».
 – 
Yoory N.
30 Ноя 2017 в 16:08
Почему работает с String, а не с int? существует статическое логическое значение (int [] int, int k) {return Arrays.asList (int) .contains (k); }
 – 
Willians Martins
21 Май 2019 в 23:57

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

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

Затем вы можете сделать (как указано выше):

STRINGS.contains("the string you want to find");
41
Peter Mortensen 5 Янв 2019 в 12:11

В 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);
}
40
assylias 13 Мар 2014 в 19:02
3
Также стоит отметить примитивные специализации.
 – 
skiwi
8 Апр 2014 в 00:11
Чтобы добавить, anyMatch JavaDoc заявляет, что это "...May not evaluate the predicate on all elements if not necessary for determining the result.", поэтому, возможно, нет необходимости продолжать обработку после нахождения совпадения.
 – 
mkobit
15 Дек 2014 в 20:21

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

29
GKFX 23 Июн 2017 в 22:08
Для этого вы можете использовать функции сортировки в том же классе ... Я должен добавить это к своему ответу.
 – 
Thomas Owens
15 Июл 2009 в 04:06
1
Тогда, я думаю, это будет стоить больше, чем подход asList (). Contains (). Если вам не нужно делать эту проверку очень часто (если честно, если это просто статический список значений, которые можно отсортировать для начала).
 – 
Joey
15 Июл 2009 в 04:10
Правда. Есть много вариантов, которые будут наиболее эффективными. Тем не менее, неплохо иметь варианты.
 – 
Thomas Owens
15 Июл 2009 в 04:13
Код, который делает это здесь: stackoverflow.com/a/48242328/9131078
 – 
O.O.Balance
14 Янв 2018 в 03:11
Сортировка всего массива для поиска - это дорого. Мы можем использовать то же процессорное время для самого поиска лайнера. Я предпочитаю бинарный поиск по коллекции, которая заранее построена в отсортированном порядке.
 – 
arunwithasmile
14 Фев 2018 в 12:51

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

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}
20
Tom Hawtin - tackline 15 Июл 2009 в 05:18
1
Выброс исключений, по-видимому, сложен, но это был бы новый способ проверки значения, если он работает. Обратной стороной является то, что перечисление должно быть определено заранее.
 – 
James P.
2 Июн 2011 в 22:20

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

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

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

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

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

  1. HashSet
  2. Двоичный
  3. asList

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

14
Peter Mortensen 5 Янв 2019 в 12:09
3
Членство в HashSet должно быть O (1), а двоичный поиск в отсортированной коллекции - O (log n).
 – 
Skylar Saveland
3 Июл 2014 в 21:21

Если у вас есть библиотека коллекций 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");
11
jhodges 19 Сен 2012 в 18:13

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

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

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

6
Ryan 7 Апр 2014 в 23:53
Это вызовет исключение нулевого указателя, если массив содержит пустую ссылку перед целевым значением.
 – 
Samuel Edwin Ward
21 Дек 2015 в 05:45
1
Оператор if должен быть: if (targetValue.equals (s)), потому что String equals имеет средство проверки instanceof.
 – 
TheArchon
3 Май 2016 в 04:37
Вместо этого используйте Objects.equals (obj1, obj2), чтобы быть нулевым.
 – 
trilogy
2 Авг 2019 в 20:12

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

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
Pang 8 Янв 2018 в 06:29

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

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;

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

12
Zar E Ahmer 1 Июн 2021 в 23:47
  1. Для массивов ограниченной длины используйте следующее (согласно camickr). Это медленно для повторных проверок, особенно для более длинных массивов (линейный поиск).

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

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

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

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

      TreeSet myElements = new TreeSet();   // Делаем это для каждого элемента (реализация *Comparable*)  моиЭлементы.добавить(следующийЭлемент);   // *В качестве альтернативы*, если массив принудительно предоставляется из другого кода:  myElements.addAll(Arrays.asList(myArray));    
    • В противном случае используйте собственный Comparator:

      класс MyComparator реализует Comparator {       int compareTo (ElementClass element1; ElementClass element2) {            // Ваше сравнение элементов            // Должно быть согласовано с равенством объектов       }        логическое равенство (объект другой компаратор) {            // Ваше равенство компараторов       }  }    // конструируем TreeSet с компаратором  TreeSet myElements = новый TreeSet (новый MyComparator());   // Делаем это для каждого элемента (реализация *Comparable*)  моиЭлементы.добавить(следующийЭлемент);    
    • Выплата: проверка существования некоторого элемента:

      // Быстрый бинарный поиск по отсортированным элементам (производительность ~ log(размер)):  логическое значение containsElement = myElements.exists(someElement);  
5
Community 23 Май 2017 в 15:18
4
Зачем возиться с TreeSet? HashSet быстрее (O (1)) и не требует упорядочивания.
 – 
Sean Owen
30 Дек 2013 в 13:53

В 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);
10
Shineed Basheer 2 Июн 2021 в 08:02

Проверь это

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
    }
}
4
Community 1 Июн 2021 в 21:50
1
Это не сработает - он будет вводить else для каждого элемента, который не соответствует (поэтому, если вы ищете "AB" в этом массиве, он пойдет туда 3 раз, так как 3 значения не являются "AB").
 – 
Bernhard Barker
4 Янв 2018 в 15:42

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

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
Pang 8 Янв 2018 в 06:27

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

Примере:

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

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

2
Ruslan 24 Фев 2019 в 23:54
5
Array.BinarySearch и Array.FindIndex являются методами .NET и не существуют в Java.
 – 
ataylor
28 Июн 2013 в 00:03
В java есть Arrays.binarySearch. Но ты прав, никакого Arrays.findIndex
 – 
mente
28 Авг 2013 в 11:27
1
Следует отметить: The array must be sorted prior to making this call. If it is not sorted, the results are undefined.
 – 
Dorian Gray
20 Дек 2019 в 00:17

Используйте следующее (метод 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(), которые также использовались в других местах.

6
Abhishek Oza 1 Июн 2021 в 21:21

Если вы не хотите, чтобы регистр регистрировался

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);
5
Akhil Babu Korkandi 21 Сен 2018 в 20:16

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

1
mandy1339 17 Май 2018 в 22:37

Проверить это можно двумя способами

A) Преобразуя массив в строку, а затем проверяя требуемую строку методом .contains

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

Б) Это более эффективный метод

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));
}
-2
Community 1 Июн 2021 в 23:51
2
Преобразование строки абсурдно неэффективно, а решение неверно, например contains (",") вернет истину.
 – 
Atuos
22 Авг 2019 в 19:04

использование Spliterator предотвращает ненужное создание List

boolean found = false;  // class variable

String search = "AB";
Spliterator<String> spl = Arrays.spliterator( VALUES, 0, VALUES.length );
while( (! found) && spl.tryAdvance(o -> found = o.equals( search )) );

found == true, если search содержится в массиве


это работает для массивов примитивов

public static final int[] VALUES = new int[] {1, 2, 3, 4};
boolean found = false;  // class variable

int search = 2;
Spliterator<Integer> spl = Arrays.spliterator( VALUES, 0, VALUES.length );
…
0
Kaplan 6 Окт 2019 в 16:00

Вы можете использовать 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.
}
233
Intracer 19 Окт 2015 в 23:49
4
Я согласен, но это все же лучше, чем «катить свой собственный», и его легче читать, чем необработанный способ java.
 – 
Jason
7 Дек 2012 в 21:48
2
 – 
slamborne
31 Янв 2014 в 06:39
45
Иногда у вас уже есть эта библиотека (по другим причинам), и это вполне верный ответ. Я искал это и уже полагаюсь на Apache Commons Lang. Спасибо за этот ответ.
 – 
GuiSim
22 Апр 2014 в 23:30
1
Или вы можете просто скопировать метод (и зависимости, если они есть).
 – 
Buffalo
9 Мар 2015 в 14:59
11
Proguard минимизирует большинство приложений для Android, помещая в приложение только те классы и функции, которые вам нужны. Это равносильно сворачиванию собственного кода или копированию исходного кода apache. И тому, кто не пользуется этой минимизацией, не нужно жаловаться на 700 или 78 Кб :)
 – 
Kenyakorn Ketsombut
12 Авг 2016 в 16:11

Попробуйте использовать метод проверки предикатов Java 8

Вот полный пример этого.

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://mytechnologyoughtt.blogspot.com/2019/10/java-8-predicate-test-method-example.html

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

2
Vipul Gulhane 2 Июн 2021 в 08:04

Краткое обновление для Java SE 9

Справочные массивы - это плохо. В этом случае нам нужен набор. Начиная с Java SE 9 у нас есть Set.of.

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

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

VALUES.contains(s)

О (1).

Правильный тип , неизменяемый , O (1) и краткий . Красивый.*

Детали оригинального ответа

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

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 - тогда это могло бы даже быть обнародовано.)

(* Чтобы быть немного больше о бренде, в API коллекций предсказуемо все еще отсутствуют неизменяемые типы коллекций, а синтаксис по-прежнему слишком многословен, на мой вкус.)

421
Community 20 Июн 2020 в 12:12
198
За исключением того, что это O (N) для создания коллекции в первую очередь :)
 – 
Drew Noakes
25 Апр 2011 в 10:54
67
Если он статичен, он, вероятно, будет использоваться довольно много раз. Таким образом, время, затрачиваемое на инициализацию набора, имеет хорошие шансы быть довольно маленьким по сравнению со стоимостью большого количества линейных поисков.
 – 
Xr.
12 Окт 2011 в 23:39
2
@ TomHawtin-tackline Почему вы говорите «в частности, нам нужен набор»? В чем преимущество Set (HashSet) в этом случае? Почему «ссылочный массив» плох (под «ссылочным массивом» вы подразумеваете список ArrayList, поддерживаемый массивом, сгенерированным вызовом Arrays.asList)?
 – 
Basil Bourque
29 Авг 2014 в 09:04
7
TreeSet будет O(log n). HashSet масштабируются таким образом, чтобы среднее количество элементов в корзине было примерно постоянным. По крайней мере, для массивов до 2 ^ 30. Могут быть воздействия, скажем, от аппаратных кешей, которые игнорируются при анализе большого О. Также предполагается, что хеш-функция работает эффективно.
 – 
Tom Hawtin - tackline
10 Сен 2014 в 03:51
3
Это не отвечает на вопрос о массиве. Вы просто говорите «не используйте массивы», что не является решением. Кроме того, вы просто говорите «Х - это плохо», но не объясняете, почему, что всегда плохо для ответа.
 – 
Minn
18 Авг 2019 в 23:37

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.
}
3
TheArchon 18 Сен 2018 в 02:29

Поскольку я имею дело с Java низкого уровня, использующим примитивные типы byte и byte [], лучшее, что я получил, - это bytes-java https://github.com/patrickfav/bytes-java кажется прекрасной работой

1
truthadjustr 26 Фев 2020 в 11:19

кратчайшее решение
массив VALUES может содержать дубликаты
начиная с Java 9

List.of(VALUES).contains(s);
4
Kaplan 15 Май 2021 в 12:31