Conversione di array in elenco in Java

Question

Come converto un array in un elenco in Java?

Ho usato il Arrays.asList() ma il comportamento (e la firma) in qualche modo sono cambiati da Java SE 1.4.2 (documenti ora in archivio) a 8 e la maggior parte degli snippet che ho trovato sul web utilizzano il comportamento 1.4.2.

Per esempio:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)

• in 1.4.2 restituisce una lista contenente gli elementi 1, 2, 3
• su 1.5.0+ restituisce un elenco contenente l'array spam

In molti casi dovrebbe essere facile da individuare, ma a volte può passare inosservato:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);

Answer 1

Nel tuo esempio, è perché non si può avere un elenco di un tipo primitivo. In altre parole, List<int> non è possibile.

È possibile, tuttavia, hanno un List<Integer> utilizzando il Integer classe che avvolge il int primitiva. Convertire la matrice a un List con il Arrays.asList metodo di utilità.

Integer[] spam = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(spam);

eseguito dal vivo al IdeOne.com .

Answer 2

In Java 8, è possibile utilizzare i flussi:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

Answer 3

Parlando modo di conversione, dipende Perché è necessario il List. Se avete bisogno solo di leggere i dati. OK, qui si va:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

Ma poi se fai qualcosa di simile a questo:

list.add(1);

si ottiene java.lang.UnsupportedOperationException. Così, per alcuni casi è anche bisogno di questo:

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

Primo approccio in realtà non converte serie ma 'rappresenta' come una List. Ma matrice è sotto il cofano con tutte le sue proprietà come numero fisso di elementi. Si prega di notare è necessario specificare il tipo quando si costruisce ArrayList.

Answer 4

Il problema è che varargs ricevuti introdotti nel Java5 e, purtroppo, Arrays.asList() ottenuto sovraccaricati con una versione vararg troppo. Così Arrays.asList(spam) è capito dal compilatore Java5 come parametro vararg di array di int.

Il problema è spiegato più in dettaglio in Effective Java 2 ° Ed., Capitolo 7, punto 42.

Answer 5

Sembra po 'in ritardo ma qui ci sono i miei due centesimi. Non possiamo avere List<int> come int è un tipo primitivo in modo che possiamo avere solo List<Integer>.

Java 8 (int array)

int[] ints = new int[] {1,2,3,4,5};
List<Integer> list11 =Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Java 8 e al di sotto (array intero)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

Hai bisogno di ArrayList e non List?

Nel caso in cui vogliamo un'implementazione specifica di List esempio ArrayList allora possiamo usare toCollection come:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

---

Perché list21 non può essere strutturalmente modificato?

Quando usiamo Arrays.asList la dimensione della lista restituita è fissata perché l'elenco restituito non è java.util.ArrayList, ma una classe statica privata definita all'interno java.util.Arrays. Quindi, se aggiungere o rimuovere elementi dalla lista restituita, verrà generato un UnsupportedOperationException. Quindi dovremmo andare con list22 quando si vuole modificare l'elenco. Se abbiamo Java8 allora possiamo anche andare con list23.

Per essere list21 trasparente può essere modificato nel senso che si può chiamare list21.set(index,element) ma l'elenco non può essere modificato strutturalmente cioè non possono aggiungere o elementi rimuovere dalla lista. È inoltre possibile controllare questo domanda .

---

Se vogliamo una lista immutabile allora possiamo avvolgerlo come:

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

Un altro punto da notare è che il metodo restituisce un Collections.unmodifiableList vista immodificabile della lista specificata. Una collezione vista non modificabile è una collezione che è modificabile ed è anche una vista su un insieme di supporto. Nota che cambia alla raccolta supporto potrebbe essere ancora possibile, e se si verificano, sono visibili attraverso la vista immodificabile.

può avere un elenco veramente immutabili in Java 10.

Java 10 (elenco verità immutabile) in due modi:

1. List.copyOf(Arrays.asList(integers))
2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

risposta di miniera per di più.

Answer 6

Recentemente ho avuto per convertire una matrice a un elenco. In seguito il programma filtrato l'elenco di tentare di rimuovere i dati. Quando si utilizza la funzione Arrays.asList (array), si crea una collezione di dimensione fissa: non è possibile aggiungere né eliminare. Questa voce spiega il problema meglio di me: Perché ricevo un UnsupportedOperationException quando si cerca di rimuovere un elemento da un elenco? .

Alla fine, ho dovuto fare una conversione "manuale":

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

suppongo che avrei potuto aggiunto conversione da una matrice ad una lista usando un'operazione (articoli) List.addAll.

Answer 7

ancora più breve:

List<Integer> list = Arrays.asList(1, 2, 3, 4);

Answer 8

Utilizzo degli array

Questo è il modo più semplice per convertire un array in List.Tuttavia, se provi ad aggiungere un nuovo elemento o a rimuovere un elemento esistente dall'elenco, an UnsupportedOperationException verrà lanciato.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

Utilizzo di ArrayList o altre implementazioni di elenchi

Puoi usare a for loop per aggiungere tutti gli elementi dell'array in a List implementazione, ad es. ArrayList:

List<Integer> list = new ArrayList<>();
for (int i : new int[]{1, 2, 3}) {
  list.add(i);
}

Utilizzo dell'API Stream in Java 8

Puoi trasformare l'array in un flusso, quindi raccogliere il flusso utilizzando diversi raccoglitori:Il raccoglitore predefinito in Java 8 utilizza ArrayList dietro lo schermo, ma puoi anche imporre la tua implementazione preferita.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

Guarda anche:

• Perché utilizziamo l'autoboxing e l'unboxing in Java?
• Quando utilizzare LinkedList su ArrayList?

Answer 9

Un'altra soluzione, se si utilizza Apache Commons-Lang:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(ArrayUtils.toObject(spam));

Dove ArrayUtils.toObject convertiti int[] a Integer[]

Answer 10

In Java 9 si ha la soluzione ancora più elegante di utilizzare liste immutabili attraverso il nuovo metodo comodo fabbrica List.of :

List<String> immutableList = List.of("one","two","three");

(spudoratamente copiato da qui )

Answer 11

Se si prendono di mira Java 8 (o successivo), si può provare questo:

int[] numbers = new int[] {1, 2, 3, 4};
List<Integer> integers = Arrays.stream(numbers)
                        .boxed().collect(Collectors.<Integer>toList());

NOTA:

Attenzione alla Collectors.<Integer>toList(), questo metodo generico aiuta ad evitare l'errore "Tipo non corrispondente: non può convertire da List<Object> a List<Integer>".

Answer 12

bisogna cast di array

Arrays.asList((Object[]) array)

Answer 13

One-liner:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});

Answer 14

1. Uso Guava:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = Lists.newArrayList(sourceArray);
   

2. Utilizzo di Apache Commons Collezioni:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = new ArrayList<>(6);
   CollectionUtils.addAll(list, array);
   

Answer 15

Quindi dipende da quale versione di Java che si sta cercando -

Java 7

 Arrays.asList(1, 2, 3);

o

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

o

Integer[] arr = new Integer[] { 1, 2, 3 };
Arrays.asList(arr);

In Java 8

int[] num = new int[] {1, 2, 3};
List<Integer> list = Arrays.stream(num)
                        .boxed().collect(Collectors.<Integer>toList())

Riferimento - http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

Answer 16

Se questo aiuta: ho avuto lo stesso problema e semplicemente scritto una generica funzione che prende un array e restituisce un ArrayList dello stesso tipo con lo stesso contenuto:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}

Answer 17

array dato:

    int[] givenArray = {2,2,3,3,4,5};

Conversione matrice integer a intero elenco

Un modo: boxed () -> restituisce l'IntStream

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

Seconda Way: mappa ogni elemento del flusso per intero e poi raccogliere

Nota: Utilizzo mapToObj è possibile convertirlo ogni elemento int nel flusso string, char flusso ecc da involucro per i (char) i

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

La conversione di un tipo di array ad un altro tipo Esempio:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

Answer 18

utilizzare due riga di codice a matrice convertito alla lista se lo si utilizza in valore intero è necessario utilizzare il tipo autoboxing per il tipo di dati di base

  Integer [] arr={1,2};
  Arrays.asList(arr);