java simple Crea ArrayList dall'array




java convert arraylist to string[] (24)

Ho una matrice che è inizializzata come:

Element[] array = {new Element(1), new Element(2), new Element(3)};

Mi piacerebbe convertire questa matrice in un oggetto della classe ArrayList.

ArrayList<Element> arraylist = ???;


Se la matrice è di tipo primitivo, le risposte fornite non funzioneranno. Ma dal momento che Java 8 è possibile utilizzare:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());

Possiamo facilmente convertire una matrice in ArrayList . Usiamo il metodo addAll() dell'interfaccia Collection allo scopo di copiare il contenuto da una lista all'altra.

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));

Da Java 8 c'è un modo più semplice per trasformare:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

new ArrayList<>(Arrays.asList(array))

 Element[] array = {new Element(1), new Element(2), new Element(3)};
 List<Element> elements=Arrays.asList(array);

(vecchio thread, ma solo 2 centesimi perché nessuno menziona Guava o altre librerie e altri dettagli)

Se puoi, usa Guava

Vale la pena sottolineare la modalità Guava, che semplifica enormemente questi shenanigans:

uso

Per una lista immutabile

Usa la classe copyOf() e i copyOf() metodi factory of() e copyOf() (gli elementi non possono essere nulli) :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Per una lista mutevole

Utilizzare la classe Lists e i suoi metodi factory newArrayList() :

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Si prega di notare anche i metodi simili per altre strutture di dati in altre classi, ad esempio in Sets .

Perché Guava?

L'attrazione principale potrebbe essere quella di ridurre il disordine dovuto ai generici per la sicurezza del tipo, in quanto l'uso dei metodi di fabbrica Guava consente di inferire il tipo per la maggior parte del tempo. Tuttavia, questo argomento contiene meno acqua da quando Java 7 è arrivato con il nuovo operatore di diamante.

Ma non è l'unica ragione (e Java 7 non è ancora dappertutto): la sintassi abbreviata è anche molto utile, e gli inizializzatori dei metodi, come visto sopra, permettono di scrivere un codice più espressivo. Fai in una chiamata Guava ciò che prende 2 con le Collezioni Java correnti.

Se non puoi ...

Per una lista immutabile

Usa la classe Arrays di JDK e il suo metodo factory asList() Collections.unmodifiableList() :

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Si noti che il tipo restituito per asList() è un List utilizza un'implementazione ArrayList concreta, ma NON è java.util.ArrayList . È un tipo interno, che emula un ArrayList ma in realtà fa riferimento direttamente all'array passato e lo rende "write through" (le modifiche si riflettono nell'array).

Vieta le modifiche attraverso alcuni dei metodi dell'API di List semplicemente estendendo una AbstractList (quindi, l'aggiunta o la rimozione di elementi non è supportata), tuttavia consente alle chiamate di set() di sovrascrivere gli elementi. Quindi questa lista non è veramente immutabile e una chiamata a asList() dovrebbe essere racchiusa in Collections.unmodifiableList() .

Vedi il prossimo passo se hai bisogno di una lista mutabile.

Per una lista mutevole

Come sopra, ma avvolto con una java.util.ArrayList effettiva:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

Per scopi educativi: il buon vecchio modo manuale

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}

Puoi farlo facilmente con l'aiuto di Arrays.asList (arrayObj);

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> arraylist =Arrays.asList(array);

Puoi farlo anche con lo streaming in Java 8.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 

Dato:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

Uso:

List<Element> listArray = Arrays.asList(array);

Dato:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

La risposta più semplice è fare:

List<Element> list = Arrays.asList(array);

Questo funzionerà bene. Ma alcuni avvertimenti:

  1. L'elenco restituito da asList ha dimensioni fisse . Quindi, se vuoi essere in grado di aggiungere o rimuovere elementi dall'elenco restituito nel tuo codice, dovrai avvolgerlo in un nuovo ArrayList . In caso contrario riceverai un UnsupportedOperationException .
  2. L'elenco restituito da asList() è supportato dall'array originale. Se si modifica l'array originale, anche l'elenco verrà modificato. Questo potrebbe essere sorprendente.

Un altro modo semplice consiste nell'aggiungere tutti gli elementi dall'array a un nuovo ArrayList utilizzando un ciclo for-each.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);

Un altro aggiornamento, quasi concluso l'anno 2014, puoi farlo anche con Java 8:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

Saranno salvati alcuni caratteri, se questo potrebbe essere solo un List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

Se usi:

new ArrayList<T>(Arrays.asList(myArray));

puoi creare e riempire due liste! Riempire due volte una grande lista è esattamente ciò che non si vuole fare perché creerà un altro array Object[] ogni volta che la capacità deve essere estesa.

Fortunatamente l'implementazione di JDK è veloce e Arrays.asList(a[]) è molto ben fatto. Crea un tipo di ArrayList denominato Arrays.ArrayList dove i dati Object [] puntano direttamente alla matrice.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

Il lato pericoloso è che se cambi la matrice iniziale, cambi la lista! Sei sicuro di volerlo? Forse si forse no.

In caso contrario, il modo più comprensibile è quello di fare questo:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

O come detto @glglgl, puoi creare un altro ArrayList indipendente con:

new ArrayList<T>(Arrays.asList(myArray));

Mi piace usare Collections , Arrays o Guava. Ma se non si adatta, o non lo senti, scrivi invece un'altra linea poco elegante.


Probabilmente hai solo bisogno di una lista, non di una lista di array. In tal caso puoi semplicemente fare:

List<Element> arraylist = Arrays.asList(array);

Anche se ci sono molte risposte perfettamente scritte a questa domanda, aggiungerò i miei input.

Supponiamo tu abbia Element[] array = { new Element(1), new Element(2), new Element(3) };

New ArrayList può essere creato nei seguenti modi

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

E supportano molto bene tutte le operazioni di ArrayList

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

Ma le seguenti operazioni restituiscono solo una vista List di un ArrayList e non un ArrayList effettivo.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

Pertanto, daranno un errore quando provano a fare alcune operazioni di ArrayList

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

Altro sulla rappresentazione di lista del link di matrice.


In Java 9 puoi usare:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

Java 9

In Java 9 , è possibile utilizzare List.of metodo factory statico per creare un letterale List . Qualcosa come il seguente:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Ciò restituirebbe una lista immutable contenente tre elementi. Se si desidera un elenco mutabile , passare tale lista al costruttore ArrayList :

new ArrayList<>(List.of(// elements vararg))

JEP 269: Metodi di fabbrica convenienti per le collezioni

JEP 269 fornisce alcuni metodi di fabbrica convenienti per l'API Java Collections . Questi metodi di fabbrica statici immutabili sono incorporati nelle interfacce List , Set e Map in Java 9 e versioni successive.


  1. Se vediamo la definizione del metodo Arrays.asList() otterrai qualcosa del genere:

     public static <T> List<T> asList(T... a) //varargs are of T type. 
    

    Quindi, potresti inizializzare l' arraylist questo modo:

     List<Element> arraylist = Arrays.asList(new Element(1),new Element(2),new Element(3));
    

    Nota : ogni new Element(int args) sarà trattato come oggetto individuale e può essere passato come var-args .

  2. Potrebbe esserci un'altra risposta anche per questa domanda.
    Se vedi la dichiarazione per il metodo java.util.Collections.addAll() otterrai qualcosa del genere:

    public static <T> boolean addAll(Collection<? super T> c, T... a);
    

    Quindi, questo codice è anche utile per farlo

    Collections.addAll(arraylist, array);
    

Un'altra soluzione Java8 (forse ho perso la risposta tra il set di grandi dimensioni, in tal caso, mi scuso). Questo crea un ArrayList (al contrario di un elenco), cioè uno può eliminare elementi

package package org.something.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

L'uscita è ...
Ciao
mondo


Poiché questa domanda è piuttosto vecchia, mi sorprende che nessuno abbia ancora suggerito la forma più semplice:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

A partire da Java 5, Arrays.asList() utilizza un parametro varargs e non è necessario costruire l'array esplicitamente.


Secondo la domanda, la risposta usando java 1.7 è:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

Tuttavia è meglio usare sempre l'interfaccia:

List<Element> arraylist = Arrays.<Element>asList(array);

Già tutti hanno fornito una buona risposta per il tuo problema. Ora da tutti i suggerimenti, è necessario decidere quale si adatta alle tue esigenze. Esistono due tipi di raccolta che è necessario conoscere. Uno è la collezione non modificata e un'altra collezione che ti permetterà di modificare l'oggetto in un secondo momento.

Quindi, qui darò un breve esempio per due casi d'uso.

  • Creazione di collezioni immutabili :: Quando non si desidera modificare l'oggetto di raccolta dopo la creazione

    List<Element> elementList = Arrays.asList(array)

  • Creazione di collezioni mutevoli :: Quando è possibile modificare l'oggetto di raccolta creato dopo la creazione.

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));


Per convertire un array in ArrayList, gli sviluppatori spesso lo fanno:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() restituirà un ArrayList che è una private static class inside Arrays , non è la classe java.util.ArrayList. The java.util.Arrays.ArrayList classe The java.util.Arrays.ArrayList ha metodi set(), get(), contains() , ma non ha metodi per aggiungere elementi, quindi la sua dimensione è fissa. Per creare una vera ArrayList, devi fare:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

Il costruttore di ArrayList può accettare un tipo di raccolta , che è anche un tipo super per java.util.Arrays.ArrayList







type-conversion