java: Arrays.asList Understanding (T ... array) Metodo per i tipi primitivi

Question

Ho scritto codice seguente e fu sorpreso di vedere l'output:

Integer a = 211; 
    int b = 211; 

    int[] array = {210,211,212}; 

    System.out.println(Arrays.asList(array).contains(a)); 
    System.out.println(Arrays.asList(array).contains(b)); 

uscita:

false 
false 

ho trovato this domanda e alcune altre domande ad esso collegate e appreso che il metodo asList non utilizza Autobox. Ho controllato il tipo restituito in Eclipse javadoc anteprima:

non riuscivo a capire questo tipo di ritorno. int[] è un oggetto e non un primitivo quindi va bene. Sono sicuro che non sto ottenendo List<Integer> (qualcosa che mi aspettavo), ma non sono sicuro di come usare la cosa che viene restituita. Le mie domande sono:

1. Come esattamente mi aspetto che i metodi di lista funzionino quando mi aspetto un elenco di numeri interi e ottenere un elenco di int []?

2. In caso di stringhe, il tipo restituito è Elenco di stringa e non elenco di stringa []. Che tipo di differenze di implementazione ci sono?

3. A che serve questo metodo per i primitivi se le cose sono così incerte?

Answer 1

ci sono, ovviamente, 3 domande qui così lascia affrontare uno per uno:

1. esattamente come mi aspetto che i metodi delle liste funzionano quando mi aspetto un elenco dei numeri interi e ottenere un elenco di int []?

Beh, List metodi funzioneranno esattamente come previsto, un List<T> è un elenco dei tipi di T.Qui T è un int[] così una volontà List<int[]> contiene le matrici come ogni elemento:

[{1, 2}, {3, 4}, {1, 6}] 

Così get(i) restituirà l'elemento ith. Nel caso di Arrays.asList del List contiene un singolo elemento, ossia la int[] modo:

int[] array = {210,211,212}; 
List<int[]> list = Arrays.asList(array); 

Sarà in

[{210, 211, 212}] 

E così

list.get(0)[0] == 210 

in caso di stringhe del ritorno type è List of String e non List of String []. Che tipo di differenze di implementazione ci sono?

String è un Object, non un tipo primitivo. La differenza deriva da questo.

3. A che serve questo metodo per i primitivi se le cose sono così incerte?

Le cose non sono incerti. Questo metodo ha come risultato definito e comportamento prevedibile. Non è molto utile per i primitivi. Questo è (ancora un altro) effetto collaterale della combinazione del sistema di tipi di Java con i generici.

Nota con Java 8 la conversione di un int[] ad un List<Integer> è molto semplice:

List<Integer> list = Arrays.stream(array). 
     boxed(). 
     collect(toList()); 

Answer 2

Non si ottiene un elenco illuminato o un elenco (che non può essere), si ottiene un elenco di matrici di numeri interi.

Quindi la vostra lista non contiene 211, contiene una matrice che poi contiene 211.

La matrice non è "srotolato" nella lista, viene aggiunto "come è" per una lista appena creata.

Quindi:

System.out.println(Arrays.asList(array).contains(array)); // Will return true 
System.out.println(Arrays.asList(a).contains(a)); // Will return true 

Answer 3

È perché Arrays.asList() è una funzione generica variadic. Modificare questo,

int[] array = {210,211,212}; 

a

Integer[] array = { 210, 211, 212 }; 

E l'uscita sarà true e true.

Answer 4

Arrays.asList accetta oggetti come parametri. Poiché int [] è un oggetto, ottieni la lista. Se vuoi una lista di numeri interi devi fare Arrays.asList (211,212,213).

Answer 5

int[] array = {210,211,212}; 

Arrays.asList(array) 

è uguale a

List<int[]> asList = Arrays.asList(array); 

Change

int[] array = {210,211,212};-Integer[] array = {210,211,212}; e funzionerà. e uguale a List<Integer> asList = Arrays.asList(array);