Java, Uproszczone sprawdzenie, czy tablica int zawiera int

Zasadniczo mój kolega powiedział, że mogę skrócić kod, używając innego sposobu sprawdzania, czy tablica int zawiera int, chociaż nie powie mi, co to jest: P.

Obecny:

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

Próbowałem również tego, chociaż z jakiegoś powodu zawsze zwraca to fałsz.

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

Czy ktoś mógłby mi pomóc?

Dziękuję Ci.

Oto rozwiązanie Java 8

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

Możesz po prostu użyć ArrayUtils.containsfrom Apache Commons Lang library.

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

To dlatego, że Arrays.asList(array)wrócę List<int[]>. arrayargument jest traktowany jako jedna wartość, którą chcesz opakować (dostajesz listę tablic int), a nie jako vararg.

Zauważ, że to czyni pracę z typów obiektów (nie prymitywów):

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

lub nawet:

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

Ale nie możesz, List<int>a autoboxing tu nie działa.

Guawa oferuje dodatkowe metody dla typów pierwotnych. Wśród nich jest metoda zawierająca te same argumenty, co Twoja.

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

Równie dobrze możesz zaimportować statycznie wersję guawy.

Zobacz wyjaśnienie prymitywów guawy

Inny sposób:

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

To modyfikuje przekazaną tablicę. Mógłbyś skopiować tablicę i pracować na oryginalnej tablicy, tj. int[] sorted = array.clone();
Ale to jest tylko przykład krótkiego kodu. Środowisko wykonawcze jest O(NlogN)zgodne z oczekiwaniamiO(N)

Wiem, że jest bardzo późno, ale spróbuj Integer[]zamiast tego int[].

1. jednorazowe zastosowania

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

2. użyj HashSet do rozważenia wydajności, jeśli używasz więcej niż raz.

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

Spróbuj tego:

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

Możesz przekonwertować swoją prymitywną tablicę int na tablicę liczb całkowitych, używając poniższego kodu Java 8,

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

Następnie użyj contains()metody, aby sprawdzić, czy lista zawiera konkretny element,

boolean containsElement = arrayElementsList.contains(key);

to działało w java 8

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

Możesz użyć java.util.Arraysclass do transformacji tablicy T[?]w List<T>obiekcie metodami takimi jak contains:

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

W zależności od tego, jak duża będzie twoja tablica int, uzyskasz znacznie lepszą wydajność, jeśli użyjesz kolekcji i .containszamiast iterować po tablicy po jednym elemencie naraz:

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

Rozwiązanie nr 1

Ponieważ pierwotne pytanie dotyczy tylko uproszczonego rozwiązania (a nie szybszego), oto rozwiązanie jednowierszowe:

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

Objaśnienie: Javadoc Arrays.toString()stanów wynik jest ujęty w nawiasy kwadratowe, a sąsiednie elementy są oddzielone znakami „,” (przecinek, po którym następuje spacja). Więc możemy na to liczyć. Najpierw konwertujemy arrayna ciąg, a następnie sprawdzamy, czy keyjest w nim zawarty. Oczywiście nie możemy zaakceptować „numerów podrzędnych” (np. „1234” zawiera „23”), więc musimy szukać wzorców, w których keypoprzedzony jest nawiasem otwierającym lub spacją, po którym następuje nawias zamykający lub przecinek.

Uwaga: użyty wzorzec wyrażenia regularnego również poprawnie obsługuje liczby ujemne (których reprezentacja w postaci łańcucha zaczyna się od znaku minus).

Rozwiązanie nr 2

To rozwiązanie jest już opublikowane, ale zawiera błędy, więc zamieszczam poprawne rozwiązanie:

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

Również to rozwiązanie ma efekt uboczny: modyfikuje array(sortuje).

Spróbuj Integer.parseInt()to zrobić .....

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;

              }


     }
}