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.containsз Apache Commons Lang library.

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

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

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

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;

              }


     }
}