Conversione di array in elenco in Java

Come faccio a convertire un array in un elenco in Java?

Ho usato il Arrays.asList()ma il comportamento (e la firma) in qualche modo cambiato da Java SE 1.4.2 (documenti ora in archivio) a 8 e la maggior parte dei frammenti che ho trovato sul web usano il comportamento 1.4.2.

Per esempio:

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

• su 1.4.2 restituisce un elenco contenente gli elementi 1, 2, 3
• su 1.5.0+ restituisce un elenco contenente lo spam dell'array

In molti casi dovrebbe essere facile da rilevare, ma a volte può scivolare inosservato:

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

Nel tuo esempio, è perché non puoi avere un Elenco di un tipo primitivo. In altre parole, List<int>non è possibile.

Tuttavia, è possibile List<Integer>utilizzare una Integerclasse che avvolge la intprimitiva. Converti l'array in a Listcon il Arrays.asListmetodo utility.

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

Vedi questo codice eseguito dal vivo su IdeOne.com .

In Java 8, è possibile utilizzare i flussi:

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

Parlando del modo di conversione, dipende dal motivo per cui hai bisogno del tuo List. Se ne hai bisogno solo per leggere i dati. OK, eccoti qui:

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

Ma poi se fai qualcosa del genere:

list.add(1);

hai capito java.lang.UnsupportedOperationException. Quindi per alcuni casi hai persino bisogno di questo:

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

Il primo approccio in realtà non converte l'array ma lo "rappresenta" come un List. Ma la matrice è sotto il cofano con tutte le sue proprietà come il numero fisso di elementi. Si noti che è necessario specificare il tipo durante la costruzione ArrayList.

Il problema è che varargs è stato introdotto in Java5 e sfortunatamente, è Arrays.asList()stato sovraccaricato anche con una versione vararg. Quindi Arrays.asList(spam)è inteso dal compilatore Java5 come un parametro vararg di array int.

Questo problema è spiegato in maggior dettaglio in 2a edizione effettiva di Java, capitolo 7, punto 42.

Sembra un po 'tardi ma ecco i miei due centesimi. Non possiamo avere List<int>come intè un tipo primitivo, quindi possiamo solo avereList<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 precedenti (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 di List?

Nel caso in cui desideriamo un'implementazione specifica, Listad esempio ArrayList, possiamo usare toCollectioncome:

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

Perché list21non può essere modificato strutturalmente?

Quando utilizziamo Arrays.asListla dimensione dell'elenco restituito viene riparato perché l'elenco restituito non lo è java.util.ArrayList, ma una classe statica privata definita all'interno java.util.Arrays. Quindi, se aggiungiamo o rimuoviamo elementi dall'elenco restituito, UnsupportedOperationExceptionverrà lanciato un. Quindi dovremmo andare con list22quando vogliamo modificare l'elenco. Se abbiamo Java8, allora possiamo anche andare conlist23 .

Per essere chiari list21può essere modificato nel senso che possiamo chiamare list21.set(index,element)ma questo elenco potrebbe non essere modificato strutturalmente, cioè non è possibile aggiungere o rimuovere elementi dall'elenco. Puoi anche controllare questa domanda .

Se vogliamo un elenco immutabile, possiamo inserirlo come segue:

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

Un altro punto da notare è che il metodo Collections.unmodifiableListrestituisce una vista non modificabile dell'elenco specificato. Una raccolta di viste non modificabile è una raccolta non modificabile ed è anche una vista su una raccolta di supporto. Si noti che le modifiche alla raccolta di backup potrebbero essere ancora possibili e, se si verificano, sono visibili attraverso la vista non modificabile.

Possiamo avere un elenco davvero immutabile in Java 9 e 10.

Elenco veramente immutabile

Java 9:

String[] objects = {"Apple", "Ball", "Cat"};
List<String> objectList = List.of(objects);

Java 10 (Elenco veramente immutabile) in due modi:

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

Controlla anche questa mia risposta per ulteriori informazioni.

Ancora più breve:

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

Di recente ho dovuto convertire un array in un elenco. Successivamente il programma ha filtrato l'elenco tentando di rimuovere i dati. Quando si utilizza la funzione Arrays.asList (array), si crea una raccolta di dimensioni fisse: non è possibile né aggiungere né eliminare. Questa voce spiega il problema meglio di me: Perché ottengo UnsupportedOperationException quando provo a 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 aggiungere la conversione da un array a un elenco usando un'operazione List.addAll (articoli).

Utilizzo di array

Questo è il modo più semplice per convertire un array in List. Tuttavia, se si tenta di aggiungere un nuovo elemento o rimuovere un elemento esistente dall'elenco, UnsupportedOperationExceptionverrà generato un.

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

È possibile utilizzare un forciclo per aggiungere tutti gli elementi dell'array in Listun'implementazione, ad esempio 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 ArrayListdietro lo schermo, ma puoi anche imporre l'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 unboxing in Java?
• Quando utilizzare LinkedList su ArrayList?

Un'altra soluzione alternativa se si utilizza apache commons-lang:

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

Dove ArrayUtils.toObject convertiti int[]aInteger[]

devi eseguire il cast in array

Arrays.asList((Object[]) array)

One-liner:

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

In Java 9 hai la soluzione ancora più elegante di utilizzare elenchi immutabili tramite il nuovo metodo factory di convenienza List.of:

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

(copiato senza vergogna da qui )

Se stai scegliendo come target Java 8 (o successivo), puoi provare questo:

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

NOTA:

Prestare attenzione a Collectors.<Integer>toList(), questo metodo generico consente di evitare l'errore "Tipo non corrispondente: impossibile convertire da List<Object>in List<Integer>".

1. Utilizzando Guava:

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

2. Utilizzo delle raccolte Apache Commons:

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

Se questo aiuta: ho avuto lo stesso problema e ho semplicemente scritto una funzione generica che accetta 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;
}

Array dato:

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

Conversione di array di numeri interi in Elenco numeri interi

Un modo: boxed () -> restituisce IntStream

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

Secondo modo: mappa ogni elemento del flusso su Intero e poi raccogli

NOTA: utilizzando mapToObj è possibile convertire ciascun elemento int in stream string, char stream ecc. Inserendo i in (char) i

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

Conversione di un tipo di array in un altro tipo Esempio:

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

Quindi dipende da quale versione Java stai provando-

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/

Puoi migliorare questa risposta, per favore, dato che questo è quello che uso ma non sono chiaro al 100%. Funziona bene ma intelliJ ha aggiunto la nuova WeatherStation [0]. Perché lo 0?

    public WeatherStation[] removeElementAtIndex(WeatherStation[] array, int index)
    {
        List<WeatherStation> list = new ArrayList<WeatherStation>(Arrays.asList(array));
        list.remove(index);
        return list.toArray(new WeatherStation[0]);
    }

utilizzare due righe di codice per convertire l'array in elenco se lo si utilizza in un valore intero, è necessario utilizzare il tipo di autoboxing per il tipo di dati primitivo

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