Java, упрощенная проверка, если int array содержит int

Ответ 1

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

public boolean contains(final int[] array, final int key) {     
    return ArrayUtils.contains(array, key);
}

Ответ 2

Это потому, что Arrays.asList(array) return List<int[]>. Аргумент array рассматривается как одно значение, которое вы хотите обернуть (вы получаете список массивов из int), а не как vararg.

Обратите внимание, что он работает с типами объектов (не примитивов):

public boolean contains(final String[] array, final String key) {
    return Arrays.asList(array).contains(key);
}

или даже:

public <T>  boolean contains(final T[] array, final T key) {
    return Arrays.asList(array).contains(key);
}

Но вы не можете иметь List<int>, и здесь не работает autoboxing.

Ответ 3

Вот решение Java 8

public static boolean contains(final int[] arr, final int key) {
    return Arrays.stream(arr).anyMatch(i -> i == key);
}

Ответ 4

Guava предлагает дополнительные методы для примитивных типов. Среди них есть метод, который принимает те же аргументы, что и ваши.

public boolean contains(final int[] array, final int key) {
    return Ints.contains(array, key);
}

Вы можете также статически импортировать версию guava.

См. Объяснение примитивов Guava

Ответ 5

Другой способ:

public boolean contains(final int[] array, final int key) {  
     Arrays.sort(array);  
     return Arrays.binarySearch(array, key) >= 0;  
}  

Изменяет переданный массив. У вас будет возможность скопировать массив и работать с исходным массивом, т.е. int[] sorted = array.clone();
Но это всего лишь пример короткого кода. Время выполнения O(NlogN), тогда как ваш путь O(N)

Ответ 6

Я знаю, что это очень поздно, но попробуйте Integer[] вместо int[].

Ответ 7

Если массив является int, double или long, мы можем использовать эти IntStream, DoubleStream или LongStream соответственно

int[] values = { 1, 33, 55, 66 };
int testValue = 33;
boolean contains = IntStream.of(values).anyMatch(x -> x == testValue);

Reference- Проверка значения в массиве

Ответ 8

1. one-off использует

List<T> list=Arrays.asList(...)
list.contains(...)

2. Использовать HashSet для рассмотрения производительности, если вы используете более одного раза.

Set <T>set =new HashSet<T>(Arrays.asList(...));
set.contains(...)

Ответ 9

Вы можете использовать класс java.util.Arrays для преобразования массива T[?] В объект List<T> с помощью методов, таких как contains:

Arrays.asList(int[] array).contains(int key);

Ответ 10

это работало в java 8

public static boolean contains(final int[] array, final int key)
{
return Arrays.stream(array).anyMatch(n->n==key);
}

Ответ 11

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

public static void arrayContains(){
    int myArray[]={2,2,5,4,8};

    int length=myArray.length;

    int toFind = 5;
    boolean found = false;

    for(int i = 0; i < length; i++) {
        if(myArray[i]==toFind) {
            found=true;
        }
    }

    System.out.println(myArray.length);
    System.out.println(found); 
}

Ответ 12

Вы можете преобразовать свой примитивный массив int в массив целых чисел, используя приведенный ниже код Java 8,

List<Integer> arrayElementsList = Arrays.stream(yourArray).boxed().collect(Collectors.toList());

А затем используйте метод contains() чтобы проверить, содержит ли список определенный элемент,

boolean containsElement = arrayElementsList.contains(key);

Ответ 13

В зависимости от того, насколько велика будет ваш массив int, вы получите гораздо лучшую производительность, если вы используете коллекции и .contains, а не итерации по массиву по одному элементу за раз:

import static org.junit.Assert.assertTrue;
import java.util.HashSet;

import org.junit.Before;
import org.junit.Test;

public class IntLookupTest {

int numberOfInts = 500000;
int toFind = 200000;
int[] array;

HashSet<Integer> intSet;

@Before
public void initializeArrayAndSet() {
    array = new int[numberOfInts];
    intSet = new HashSet<Integer>();
    for(int i = 0; i < numberOfInts; i++) {
        array[i] = i;
        intSet.add(i);
    }
}

@Test
public void lookupUsingCollections() {
    assertTrue(intSet.contains(toFind));
}

@Test
public void iterateArray() {
    assertTrue(contains(array, toFind));

}

public boolean contains(final int[] array, final int key) {
    for (final int i : array) {
        if (i == key) {
            return true;
        }
    }
    return false;
}
}

Ответ 14

Решение № 1

Поскольку исходный вопрос требует только упрощенного решения (а не более быстрого), здесь однострочное решение:

public boolean contains(int[] array, int key) {
    return Arrays.toString(array).matches(".*[\\[ ]" + key + "[\\],].*");
}

Объяснение: Javadoc из Arrays.toString() указывает, что результат заключен в квадратные скобки, а смежные элементы разделены символами "," (запятая, за которой следует пробел). Поэтому мы можем рассчитывать на это. Сначала мы преобразуем array в строку, а затем проверяем, содержится ли key в этой строке. Конечно, мы не можем принимать "под-номера" (например, "1234" содержит "23" ), поэтому мы должны искать шаблоны, где key предшествует открывающая скобка или пробел, а затем закрывающая скобка или запятая.

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

Решение №2

Это решение уже опубликовано, но оно содержит ошибки, поэтому я отправляю правильное решение:

public boolean contains(int[] array, int key) {
    Arrays.sort(array);
    return Arrays.binarySearch(array, key) >= 0;
}

Также это решение имеет побочный эффект: он изменяет array (сортирует его).

Ответ 15

Попробуйте Integer.parseInt() сделать это.....

public boolean chkInt(final int[] array){
    int key = false;

    for (Integer i : array){


          try{

                   Integer.parseInt(i);
                   key = true;
                   return key;

             }catch(NumberFormatException ex){

                   key = false;

                   return key;

              }


     }
}