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

В основном, мой помощник говорил, что я мог бы сделать свой код короче, используя другой способ проверки, если int-массив содержит int, хотя он не скажет мне, что это такое: P.

Текущий:

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

Также попробовал это, хотя по какой-то причине он всегда возвращает false.

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

Может ли кто-нибудь помочь мне?

Спасибо.

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

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

Это потому, что Arrays.asList(array) возвращает List . аргумент array рассматривается как одно значение, которое вы хотите обернуть (вы получаете список массивов ints), а не как vararg.

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

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

или даже:

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

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

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

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

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

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

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

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

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

 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)

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

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

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

Ссылка – проверка значения в массиве

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

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

1. Однократное использование

 List list=Arrays.asList(...) list.contains(...) 

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

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

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

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

В зависимости от того, насколько велика будет ваш массив 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 intSet; @Before public void initializeArrayAndSet() { array = new int[numberOfInts]; intSet = new HashSet(); 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; } } 

Решение №1

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

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

Объяснение: Javadoc of 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 (сортирует его).

Попробуйте 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; } } } 
Давайте будем гением компьютера.