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

Попытайтесь использовать метод тестирования 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

Можно проверить его двумя методами

А Путем преобразования массива в строку и затем проверить необходимую строку .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"));

B), это - больше efficent метода

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

    }

использование 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 );
…

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

enum Values {
    AB, BC, CD, AE
}

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

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

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

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

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

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

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

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

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

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

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

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, есть ли хороший способ проверки, содержит ли VALUES s? "

VALUES.contains(s)

O (1).

Обновление: Начиная с Java SE 9 у нас есть Set.of .

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

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

(Чтобы подробнее рассказать о бренде,

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

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

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

1. HashSet
2. asList
3. sort & binary

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

1. HashSet
2. Binary
3. asList

Так что в любом случае, HashSet - победа.