Java, упрощенная проверка, содержит ли массив int 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);
}

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

Спасибо.

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

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

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

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

Это потому что Arrays.asList(array)возвращение List<int[]>. arrayАргумент рассматривается как одно значение, которое вы хотите обернуть (вы получаете список массивов целых чисел), а не как 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>и автобокс здесь не работает.

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

public boolean contains(final int[] array, final int key) {
    return Ints.contains(array, 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[].

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

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

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

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

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

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

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

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

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

boolean containsElement = arrayElementsList.contains(key);

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

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

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

Arrays.asList(int[] array).contains(int 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<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;
}
}

Решение # 1

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

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

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

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

Решение # 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;

              }


     }
}