Verifica se un elemento esiste in una matrice

Question

Un codice Java semplice per verificare se un elemento è presente in un array o no:

import java.util.Arrays; 

public class Main { 
    static int[] numbers = {813, 907, 908, 909, 910}; 

    public static void main(String[] args) { 
     int number = 907; 
     //Integer number = 907; // the same thing -- it's not found. 
     boolean b = Arrays.asList(numbers).contains(number); 
     System.out.println(b); // => false 
    } 
} 

1) Perché non si trovano 907 nella matrice?

2) Se c'è un modo migliore per farlo, vai avanti e condividi le tue conoscenze.

UPDATE:

Si diceva che asList converte il int[] in un List<int[]> con un unico socio: l'elenco originale. Tuttavia, mi aspetto che il seguente codice di darmi 1, ma mi dà 5:

System.out.println(Arrays.asList(numbers).size()); 

Answer 1

Il problema è che Arrays.asList(numbers) non sta facendo quello che tu pensi. Si sta convertendo il tuo int[] in un List<int[]> con un singolo membro: l'elenco originale.

È possibile eseguire una ricerca lineare semplice o, se l'array numbers è sempre ordinato, utilizzare Arrays.binarySearch(numbers, 907); e verificare se il risultato è negativo (ovvero non trovato).

Answer 2

liste non contengono primitive, così Arrays.asList (int []) produrrà un List con un ingresso di tipo int[].

Questo codice funziona:

static Integer[] numbers = {813, 907, 908, 909, 910}; 

public static void main(String[] args) { 
    Integer number = 907; 
    boolean b = Arrays.asList(numbers).contains(number); 
    System.out.println(b); // => false 
} 

per la tua domanda come quello che sarà Arrays.asList(numbers) contenere fintanto che si tratta di un int[]:

Questo codice:

static int[] numbers = {813, 907, 908, 909, 910}; 

public static void main(String[] args) { 
    int number = 907; 
    List<int[]> list = Arrays.asList(numbers); 

    boolean b = list.contains(number); 
    System.out.println(b); // => false 
    System.out.println("list: " + list); 
    for(int[] next : list) { 
     System.out.println("content: " + Arrays.toString(next)); 
    } 
} 

ha questo risultato:

false 
list: [[I@da89a7] 
content: [813, 907, 908, 909, 910] 

Come si può vedere, lo list contiene un elemento di tipo int[] (il [[I indica lo int[]). Ha gli elementi che sono stati inizialmente creati.

Answer 3

Poiché l'array è ordinato, è possibile utilizzare Arrays.binarySearch().

Ciò consente di non dover convertire prima in un List. Controlla il codice di ritorno di questo metodo: se è positivo, l'elemento è nell'array; se è negativo, non è:

int number = 907; 
System.out.println(Arrays.binarySearch(numbers, number) >= 0); 

Answer 4

Con guava ImmutableSet:

public class Main { 

    private static final Set<Integer> NUMBERS = ImmutableSet.of(813, 907, 908, 909, 910); 

    public static void main(final String[] args) { 
     final int number = 907; 
     final boolean b = NUMBERS.contains(number); 
     System.out.println(b); // true 
    } 
} 

ImmutableSet assicura nessuno aggiunge qualcosa alla NUMBERS

Answer 5

Utilizzare questo codice.Questa è solo una di quelle volte che hai avuto modo di trattare con stranezze fortemente tipizzati di Java :)

import java.util.Arrays; 

    public class Main { 
     static Integer[] numbers = {813, 907, 908, 909, 910}; 

     public static void main(String[] args) { 
     Integer number = new Integer(907); 

     boolean b = Arrays.asList(numbers).contains(number); 
     System.out.println(b); 
    } 
} 

Answer 6

Si potrebbe utilizzare un ciclo passando attraverso l'array e abbinare ogni elemento con quello che si sta cercando . Successivamente puoi andare da lì.

Per il motivo per cui non funziona è lo stesso motivo che altri hanno detto prima.