Java, controllo semplificato se l'array int contiene int

Fondamentalmente il mio amico ha detto che potrei accorciare il mio codice usando un modo diverso di verificare se un array int contiene un int, anche se non mi dice di cosa si tratta: P.

Attuale:

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

Ho anche provato questo, anche se per qualche motivo restituisce sempre falso.

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

Qualcuno può aiutarmi?

Grazie.

Ecco la soluzione Java 8

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

Potresti semplicemente usare ArrayUtils.containsda Apache Commons Lang library.

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

È perché Arrays.asList(array)ritorno List<int[]>. arrayargomento è trattato come un valore che vuoi racchiudere (ottieni un elenco di array di int), non come vararg.

Nota che fa il lavoro con i tipi di oggetto (non primitive):

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

o anche:

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

Ma non puoi avere List<int>e l'autoboxing non funziona qui.

Guava offre metodi aggiuntivi per i tipi primitivi. Tra questi un metodo contiene che accetta gli stessi argomenti dei tuoi.

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

Potresti anche importare staticamente la versione guava.

Vedi Guava Primitives Explained

Un modo diverso:

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

Ciò modifica l'array passato. Avresti la possibilità di copiare l'array e lavorare sull'array originale cioè int[] sorted = array.clone();
Ma questo è solo un esempio di codice breve. Il tempo di esecuzione è O(NlogN)mentre la tua strada èO(N)

So che è molto tardi, ma prova Integer[]invece int[].

1. usi una tantum

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

2.usare HashSet per la considerazione delle prestazioni se si utilizza più di una volta.

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

Prova questo:

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

Puoi convertire il tuo array int primitivo in un elenco di numeri interi utilizzando il codice Java 8 di seguito,

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

Quindi usa il contains()metodo per verificare se l'elenco contiene un particolare elemento,

boolean containsElement = arrayElementsList.contains(key);

questo ha funzionato in java 8

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

Puoi usare java.util.Arraysclass per trasformare l'array T[?]in un List<T>oggetto con metodi come contains:

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

A seconda di quanto sarà grande il tuo array di int, otterrai prestazioni molto migliori se usi le collezioni e .containsinvece di iterare sull'array un elemento alla volta:

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

Soluzione n. 1

Poiché la domanda originale vuole solo una soluzione semplificata (e non una più veloce), ecco una soluzione di una riga:

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

Spiegazione: Javadoc degli Arrays.toString()stati il ​​risultato è racchiuso tra parentesi quadre e gli elementi adiacenti sono separati dai caratteri "," (una virgola seguita da uno spazio). Quindi possiamo contare su questo. Per prima cosa convertiamo arrayin una stringa, quindi controlliamo se keyè contenuto in questa stringa. Ovviamente non possiamo accettare "sotto-numeri" (es. "1234" contiene "23"), quindi dobbiamo cercare schemi in cui il keyè preceduto da una parentesi aperta o uno spazio e seguito da una parentesi chiusa o una virgola.

Nota: il pattern regexp utilizzato gestisce correttamente anche i numeri negativi (la cui rappresentazione di stringa inizia con un segno meno).

Soluzione n. 2

Questa soluzione è già pubblicata ma contiene errori, quindi inserisco la soluzione corretta:

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

Anche questa soluzione ha un effetto collaterale: modifica il array(lo ordina).

Prova Integer.parseInt()a farlo .....

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;

              }


     }
}