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

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

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

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

15.07.2009 00:03:21
Долгий путь, но вы можете использовать цикл for: "for (String s: VALUES) if (s.equals (" MYVALUE ")) вернет true;
Zack 15.07.2009 00:51:07
@camickr. На ваш вопрос я проголосовал за этот вопрос и ваш ответ - теперь - потому что это сэкономило мне 30 минут и 20 строк кода, безобразно пишущих для циклов, - теперь -. Не читал три года назад. (Кстати, спасибо :))
Pursuit 9.08.2012 23:26:21
@ camickr - у меня почти идентичная ситуация с этим: stackoverflow.com/a/223929/12943 Он просто продолжает получать голоса, но был просто копией / вставкой из документации Sun. Я предполагаю, что оценка основана на том, сколько помощи вы предоставили, а не на том, сколько усилий вы вложили в нее - и в основном на то, насколько быстро вы ее опубликовали! Может быть, мы наткнулись на секрет Джона Скита! Ну, хороший ответ, +1 для вас.
Bill K 29.04.2013 06:50:36
Если вы используете Apache Commons, то org.apache.commons.lang.ArrayUtils.contains () сделает это за вас.
Mr. Boy 12.11.2013 21:05:32
@camickr, потому что люди, как и я, задают вопрос в Google, нажимают на результат SO, видят ваш ответ, проверяют его, он работает, выдает ответ, а затем уходит.
Aequitas 20.07.2015 02:41:26
29 ОТВЕТОВ
РЕШЕНИЕ
Arrays.asList(yourArray).contains(yourValue)

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


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

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);
2901
8.10.2018 12:35:00
Мне несколько любопытно, как это можно сравнить с функциями поиска в классе Arrays, с итерациями по массиву и использованием функции equals () или == для примитивов.
Thomas Owens 15.07.2009 00:06:07
Вы не теряете много, так как asList () возвращает ArrayList, в основе которого лежит массив. Конструктор просто изменит ссылку, так что там не так много работы. И содержит () / indexOf () будет повторять и использовать equals (). Для примитивов вам лучше кодировать его самостоятельно. Для строк или других классов разница не будет заметна.
Joey 15.07.2009 00:09:07
Странно, NetBeans утверждает, что Arrays.asList (праздничные дни) для int [] праздничных дней возвращает «список <int []>», а не «список <int>». Он содержит только один элемент. Значение Contains не работает, поскольку в нем только один элемент; массив int.
Nyerguds 13.11.2010 13:15:59
Nyerguds: действительно, это не работает для примитивов. В Java примитивные типы не могут быть универсальными. asList объявлен как <T> список <T> asList (T ...). Когда вы передаете в него int [], компилятор выводит T = int [], потому что он не может вывести T = int, потому что примитивы не могут быть универсальными.
CromTheDestroyer 14.06.2011 16:51:20
@Joey просто примечание стороны, что это ArrayList, но не java.util.ArrayListтак , как ожидалось, реальный класс возвращаемый: java.util.Arrays.ArrayList<E>определяется как: public class java.util.Arrays {private static class ArrayList<E> ... {}}.
TWiStErRob 17.10.2012 09:16:12

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

28
23.06.2017 19:08:04
Вы можете использовать функции сортировки в том же классе, чтобы выполнить это ... Я должен добавить это к моему ответу.
Thomas Owens 15.07.2009 00:06:44
Наверное, будет стоить дороже, чем подход asList (). Contains (). Если вам не нужно делать эту проверку очень часто (но если это просто статический список значений, которые можно отсортировать для начала, если честно).
Joey 15.07.2009 00:10:56
Правда. Есть много переменных, которые будут наиболее эффективными. Хотя хорошо иметь варианты.
Thomas Owens 15.07.2009 00:13:48
Некоторый код, который делает это здесь: stackoverflow.com/a/48242328/9131078
O.O.Balance 14.01.2018 00:11:47
Сортировка целого массива с целью поиска обходится дорого. Мы можем использовать то же время процессора для самого поиска лайнера. Я предпочитаю бинарный поиск по коллекции, которая заранее составлена ​​в отсортированном порядке.
arunwithasmile 14.02.2018 09:51:19

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

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

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

71
14.07.2014 15:13:06
Кроме того, как я сказал в своем ответе, если вы используете класс Arrays, вы можете отсортировать массив, а затем выполнить бинарный поиск по вновь отсортированному массиву.
Thomas Owens 15.07.2009 00:10:39
@ Томас: я согласен. Или вы можете просто добавить все в TreeSet; такая же сложность. Я бы использовал массивы, если они не меняются (возможно, сохраните немного локальности памяти, так как ссылки расположены непрерывно, а строки - нет). Я бы использовал набор, если это изменится со временем.
Uri 15.07.2009 00:14:59

Краткое обновление для 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)

O (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 коллекций, по-видимому, все еще не содержит неизменяемые типы коллекций, а синтаксис все еще слишком многословен, на мой вкус.)

356
20.12.2019 13:14:31
За исключением того, что это O (N), чтобы создать коллекцию в первую очередь :)
Drew Noakes 25.04.2011 06:54:21
Если он статичен, он, вероятно, будет использоваться довольно много раз. Таким образом, время, затрачиваемое на инициализацию набора, имеет хорошие шансы быть достаточно маленьким по сравнению со стоимостью многих линейных поисков.
Xr. 12.10.2011 19:39:04
При создании коллекции будет доминировать время загрузки кода (которое технически равно O (n), но практически постоянно).
Tom Hawtin - tackline 7.03.2012 13:23:09
@ TomHawtin-tackline Почему вы говорите «в частности, здесь мы хотим, чтобы набор»? В чем преимущество набора (HashSet) в этом случае? Почему «ссылочный массив» плох (под «ссылочным массивом» подразумевается ArrayList, поддерживаемый массивом, сгенерированным вызовом Arrays.asList)?
Basil Bourque 29.08.2014 05:04:50
@nmr А TreeSetбудет O(log n). HashSets масштабируются таким образом, чтобы среднее количество элементов в корзине было примерно постоянным. По крайней мере, для массивов до 2 ^ 30. Скажем, могут быть аффекты, скажем, от аппаратных кешей, которые анализ big-O игнорирует. Также предполагается, что хэш-функция работает эффективно.
Tom Hawtin - tackline 9.09.2014 23:51:54

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

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}
17
15.07.2009 01:18:26
Бросок исключений, по-видимому, тяжел, но это был бы новый способ проверки значения, если он работает. Недостатком является то, что перечисление должно быть определено заранее.
James P. 2.06.2011 18:20:36

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

При использовании размера массива 10K были получены следующие результаты:

Сортировка и поиск: 15
Двоичный поиск: 0
asList.contains: 0

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

Сортировка и поиск: 156
Двоичный поиск: 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));
    }
}
49
2.04.2019 18:05:30
Я не понимаю этот код. Вы сортируете массив 'strings' и используете один и тот же (отсортированный) массив в обоих вызовах binarySearch. Как это может показать что-нибудь кроме оптимизации времени выполнения HotSpot? То же самое с вызовом asList.contains. Вы создаете список из отсортированного массива и затем содержит в нем самое высокое значение. Конечно, это займет время. В чем смысл этого теста? Не говоря уже о неправильно написанном микробенчмарке
Erik 30.05.2013 09:16:54
Кроме того, поскольку бинарный поиск может применяться только к отсортированному набору, сортировка и поиск являются единственным возможным способом использования бинарного поиска.
Erik 30.05.2013 09:18:51
Сортировка может быть уже выполнена по ряду других причин, например, она может быть отсортирована по init и никогда не изменяться. Там есть использование в тестировании времени поиска самостоятельно. Однако, где это падает, это менее чем звездный пример микробенчмаркинга. Общеизвестно, что микробенчмарки трудно получить правильные в Java, и они должны, например, включать выполнение тестового кода, достаточного для оптимизации горячей точки перед запуском реального теста, не говоря уже о запуске реального тестового кода больше, чем ONCE с таймером. Пример ловушек
Thor84no 24.10.2013 12:25:37
Этот тест некорректен, поскольку он запускает все 3 теста в одном экземпляре JVM. Более поздние тесты могут выиграть от более ранних прогревов кеша, JIT и т. Д.
Steve Kuo 11.01.2014 00:39:03
Этот тест на самом деле совершенно не связан. Сортировка и поиск имеют линейную (n * log (n)) сложность, двоичный поиск - логарифмический, а ArrayUtils.contains - линейный. Бесполезно сравнивать эти решения, поскольку они находятся в совершенно разных классах сложности.
dragn 11.09.2014 13:47:14

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

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

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

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

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

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

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

13
5.01.2019 09:09:27
Членство в HashSet должно быть O (1), а двоичный поиск в отсортированной коллекции - O (log n).
Skylar Saveland 3.07.2014 17:21:07

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

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

Тогда вы можете сделать (как выше):

STRINGS.contains("the string you want to find");
37
5.01.2019 09:11:02

Вы можете использовать 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.
}
203
19.10.2015 20:49:40
@ max4ever Я согласен, но это все же лучше, чем «сворачивать свои», и легче читать, чем сырой Java-способ.
Jason 7.12.2012 17:48:11
slamborne 31.01.2014 02:39:16
@ max4ever Иногда эта библиотека уже включена (по другим причинам), и это вполне верный ответ. Я искал это и уже зависел от Apache Commons Lang. Спасибо за этот ответ.
GuiSim 22.04.2014 19:30:57
Или вы можете просто скопировать метод (и зависимости, если таковые имеются).
Buffalo 9.03.2015 11:59:10
@ max4ever Proguard минимизирует большинство приложений для Android, добавляя в приложение только те классы и функции, которые вам нужны. Это равносильно тому, чтобы свернуть свой собственный или скопировать источник информации об Apache. И тот, кто не использует эту минимализацию, не должен жаловаться на 700 КБ или 78 КБ :)
Kenyakorn Ketsombut 12.08.2016 13:11:56

Если у вас есть библиотека коллекций 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
19.09.2012 14:13:40

Просто выполните это вручную:

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;
}
158
5.01.2019 09:14:53
@Phoexo Это решение, очевидно, быстрее, потому что принятый ответ оборачивает массив в список и вызывает метод contains () в этом списке, в то время как мое решение в основном делает то, что будет делать только only ().
icza 10.10.2012 11:25:21
@AlastorMoody e == v очень быстро проверяет равенство ссылок. Если тот же объект (тот же самый по ссылке) находится в массиве, он будет найден быстрее. Если это не тот же экземпляр, он все равно может быть таким же, как заявлено методом equals (), это то, что проверяется, если ссылки не совпадают.
icza 15.01.2013 08:39:10
Почему эта функция не является частью Java? Неудивительно, что люди говорят, что Java раздутая ... посмотрите на все ответы выше этого, которые используют кучу библиотек, когда все, что вам нужно, это цикл for. Дети в эти дни!
phreakhead 2.04.2013 19:30:41
@phreakhead Это часть Java, см.Collection.contains(Object)
Steve Kuo 11.01.2014 00:37:26
@icza Если вы посмотрите на источник, Arraysи ArrayListоказывается, что это не обязательно быстрее, чем версия, используемая Arrays.asList(...).contains(...). Затраты на создание ArrayListчрезвычайно малы и ArrayList.contains()используют более умный цикл (фактически он использует два разных цикла), чем тот, который показан выше (JDK 7).
Axel 11.02.2014 07:41:22
  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);
5
23.05.2017 12:18:30
Зачем беспокоиться TreeSet? HashSetбыстрее (O (1)) и не требует упорядочения.
Sean Owen 30.12.2013 09:53:50

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

Пример:

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

ложь - не существует

2
24.02.2019 20:54:53
Array.BinarySearchи Array.FindIndexявляются методами .NET и не существуют в Java.
ataylor 27.06.2013 20:03:05
@ataylor В Java есть Arrays.binarySearch. Но вы правы, не Arrays.findIndex
mente 28.08.2013 07:27:05
Стоит отметить:The array must be sorted prior to making this call. If it is not sorted, the results are undefined.
Dorian Gray 19.12.2019 21:17:23

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

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
8.01.2018 03:27:44

С 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);
}
35
13.03.2014 15:02:36
Стоит также отметить примитивные специализации.
skiwi 7.04.2014 20:11:28
Кроме того, anyMatchJavaDoc заявляет, что это "...May not evaluate the predicate on all elements if not necessary for determining the result."так, поэтому может не потребоваться продолжать обработку после нахождения соответствия.
mkobit 15.12.2014 17:21:18

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

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

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

7
7.04.2014 19:53:57
Это вызовет исключение нулевого указателя, если массив содержит нулевую ссылку перед целевым значением.
Samuel Edwin Ward 21.12.2015 02:45:48
оператор if должен быть: if (targetValue.equals (s)), потому что String equals имеет проверку экземпляра.
WIll 3.05.2016 01:37:05
вместо этого используйте Objects.equals (obj1, obj2) для обеспечения нулевой безопасности.
trilogy 2.08.2019 17:12:26

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

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
69
4.12.2017 02:00:36
ваш пример двоичного поиска должен возвращать> 0;
Will Sherwood 27.03.2015 01:33:39
Почему? Я думаю, что он должен возвращать> -1, так как 0 будет означать, что он содержится в начале массива.
mbelow 25.05.2016 15:22:50
Первый вариант с (a >= 0)был правильным, просто проверьте документы , они говорят: «Обратите внимание, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ найден».
Yoory N. 30.11.2017 13:08:56
Почему работает с String, а не с int? статическое логическое значение существует (int [] ints, int k) {return Arrays.asList (ints) .contains (k); }
Willians Martins 21.05.2019 20:57:05

Проверь это

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
8.01.2018 03:26:35
Это не работает - он будет вводить elseдля каждого элемента, который не соответствует (поэтому, если вы ищете «AB» в этом массиве, он будет идти туда 3 раза, так как 3 значения не являются «AB» «).
Dukeling 4.01.2018 12:42:24

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

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;

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

8
25.06.2014 07:24:12

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

4
5.01.2019 09:19:44
Я очень поздно присоединяюсь к этой дискуссии, но, поскольку мой подход к решению этой проблемы, когда я столкнулся с ней несколько лет назад, несколько отличался от других ответов, уже опубликованных здесь, я публикую то решение, которое я использовал в то время, здесь, на случай, если кто-нибудь найдет это полезным.
Abhishek Oza 5.01.2019 10:22:44

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

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
8.01.2018 03:29:05

В Java 8 используйте Streams.

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
28.04.2015 06:40:26
Есть ли преимущества у этого подхода?
Johannes Stadler 10.06.2015 08:41:16
Это не отвечает на вопрос.
Florian F 26.10.2018 14:36:54

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
17.09.2018 23:29:40
Arrays.asListэто не O (n). Это просто легкая обертка. Посмотрите на реализацию.
Patrick Parker 8.09.2018 06:44:24

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

1
17.05.2018 19:37:40

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

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);
3
21.09.2018 17:16:22

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

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
23.09.2019 22:25:34
Преобразование строк абсурдно неэффективно, и решение неверно, например, содержит (",") вернет истину.
Atuos 22.08.2019 16:04:44

Попробуйте использовать метод теста предикатов 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://mytechnologythought.blogspot.com/2019/10/java-8-predicate-test-method-example.html

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

1
13.10.2019 06:54:38

использование 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
6.10.2019 13:00:37

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

0
26.02.2020 08:19:14