Ik heb een array die is geïnitialiseerd als:

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

Ik wil deze array graag omzetten in een object van de arraylistklasse.

ArrayList<Element> arraylist = ???;

Antwoord 1, autoriteit 100%

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

Antwoord 2, autoriteit 20%

Gegeven:

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

Het eenvoudigste antwoord is te doen:

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

Dit werkt prima. Maar enkele kanttekeningen:

1. De lijst die wordt geretourneerd door asList heeft een vaste grootte. Dus als je elementen uit de geretourneerde lijst in je code wilt kunnen toevoegen of verwijderen, moet je deze in een nieuwe arraylistplaatsen. Anders krijg je een UnsupportedOperationException.
2. De lijst die wordt geretourneerd door asList()wordt ondersteund door de originele array. Als u de oorspronkelijke array wijzigt, wordt de lijst ook gewijzigd. Dit kan verrassend zijn.

Antwoord 3, autoriteit 8%

^{(oude thread, maar slechts 2 cent, aangezien geen Guava of andere bibliotheken en enkele andere details worden genoemd)}

Als je kunt, gebruik dan guave

Het is de moeite waard om te wijzen op de Guava-manier, die deze streken aanzienlijk vereenvoudigt:

Gebruik

Voor een onveranderlijke lijst

Gebruik de ImmutableList-klasse en de of()en copyOf()fabrieksmethoden ^{(elementen mogen niet null zijn)}:

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

Voor een veranderlijke lijst

Gebruik de Lists-klasse en zijn newArrayList()fabrieksmethoden:

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

Let ook op de vergelijkbare methoden voor andere datastructuren in andere klassen, bijvoorbeeld in Sets.

Waarom Guava?

De belangrijkste attractie zou kunnen zijn om de rommel als gevolg van generieke geneesmiddelen voor typeveiligheid te verminderen, zoals het gebruik van de Guava fabrieksmethodenkunnen de typen meestal worden afgeleid. Dit argument houdt echter minder steek sinds Java 7 arriveerde met de nieuwe diamantoperator.

Maar het is niet de enige reden (en Java 7 is nog niet overal): de steno-syntaxis is ook erg handig, en de initialisatieprogramma’s, zoals hierboven te zien, maken het mogelijk om meer expressieve code te schrijven. Je doet in één Guava-aanroep wat er nodig is met de huidige Java-collecties.

Als je niet kunt…

Voor een onveranderlijke lijst

Gebruik de Arraysklasse en zijn asList()fabrieksmethode, verpakt met een Collections.unmodifiableList():

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

Merk op dat het geretourneerde type voor asList()een Listis met een concrete arraylist-implementatie, maar het is NIETjava.util.ArrayList. Het is een innerlijk type, dat een arraylistemuleert, maar in feite rechtstreeks verwijst naar de doorgegeven array en deze “doorschrijft” (wijzigingen worden weerspiegeld in de array).

Het verbiedt aanpassingen door middel van sommige van de ListAPI’s-methoden door simpelweg een AbstractListuit te breiden (het toevoegen of verwijderen van elementen wordt dus niet ondersteund), maar het staat wel oproepen toe om set()om elementen te overschrijven. Deze lijst is dus niet echt onveranderlijk en een aanroep naar asList()moet worden afgesloten met Collections.unmodifiableList().

Zie de volgende stap als je een veranderlijke lijst nodig hebt.

Voor een veranderlijke lijst

Hetzelfde als hierboven, maar omwikkeld met een echte java.util.ArrayList:

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+

Voor educatieve doeleinden: de ouderwetse handmatige manier

// 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);
}

Antwoord 4, autoriteit 5%

Aangezien deze vraag vrij oud is, verbaast het me dat nog niemand de eenvoudigste vorm heeft voorgesteld:

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

Vanaf Java 5 neemt Arrays.asList()een varargs-parameter en hoeft u de array niet expliciet te construeren.

Antwoord 5, autoriteit 5%

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

Zorg ervoor dat myArrayvan hetzelfde type is als T. U krijgt een compilerfout als u bijvoorbeeld een List<Integer>probeert te maken van een array van int.

Antwoord 6, autoriteit 2%

Een andere manier (hoewel in wezen gelijk aan de new ArrayList(Arrays.asList(array))-oplossing qua prestaties:

Collections.addAll(arraylist, array);

Antwoord 7, autoriteit 2%

Java 9

In Java 9kun je List.ofstatische fabrieksmethode om een letterlijke Listte maken. Iets als het volgende:

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

Hierdoor zou dit een onveranderlijk Lijst met drie elementen. Als u een –scherm -lijst wilt, dient u die lijst door naar de arraylistconstructor:

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

JEP 269: Gemaksfabrieksmethoden voor collecties

JEP 269 biedt enkele gemak fabrieksmethoden voor Java-collecties API. Deze onveranderlijke statische fabrieksmethoden zijn ingebouwd in de List, Set, en Mapinterfaces in Java 9 en later.

Antwoord 8, Autoriteit 2%

U hebt waarschijnlijk gewoon een lijst nodig, geen arrayclist. In dat geval kunt u gewoon doen:

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

Antwoord 9, Autoriteit 2%

Een andere update, bijna eind 2014, kunt u het ook met Java 8 doen:

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

Een paar tekens zouden worden opgeslagen, als dit slechts een List

zou kunnen zijn

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

Antwoord 10

Als u :

. gebruikt

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

u magtwee lijsten en vullen! Twee keer een grote lijst vullen is precies wat u niet wilt doen, omdat het elke keer dat de capaciteit moet worden uitgebreid, een andere Object[]-array creëert.

Gelukkig is de JDK-implementatie snel en is Arrays.asList(a[])erg goed gedaan. Het creëert een soort ArrayList genaamd Arrays.ArrayList waarbij de Object[]-gegevens rechtstreeks naar de array verwijzen.

// 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
    }
    ....
}

De gevaarlijke kant is dat als je de initiële array verandert, je de lijst verandert!Weet je zeker dat je dat wilt? Misschien wel, misschien niet.

Zo niet, dan is de meest begrijpelijke manier om dit te doen:

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

Of zoals gezegd @glglgl, je kunt een andere onafhankelijke ArrayList maken met :

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

Ik gebruik graag Collections, Arraysof Guava. Maar als het niet past, of je voelt het niet, schrijf dan gewoon een andere onelegante regel.

Antwoord 11

In Java 9kun je het volgende gebruiken:

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

Antwoord 12

Volgens de vraag is het antwoord met java 1.7:

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

Het is echter beter om altijd de interface te gebruiken:

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

Antwoord 13

// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

Antwoord 14

Sinds Java 8 is er een eenvoudigere manier om te transformeren:

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

Antwoord 15

U kunt op verschillende manieren converteren

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

2. List<Element> list = new ArrayList();
Collections.addAll(list, array);

3. Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));

Voor meer details kun je verwijzen naar http ://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

Antwoord 16

zoals iedereen zei, dit zal dit doen

new ArrayList<>(Arrays.asList("1","2","3","4"));

en de gebruikelijke nieuwste manier om arrays te maken is observableArrays

ObservableList:een lijst waarmee luisteraars wijzigingen kunnen volgen wanneer ze zich voordoen.

voor Java SE kunt u proberen

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

dat is volgens Oracle Docs

observableArrayList()
Creëert een nieuwe lege waarneembare lijst die wordt ondersteund door een arraylist.
observableArrayList(E… items)
Creëert een nieuwe waarneembare arraylijst met items die eraan zijn toegevoegd.

Java 9 bijwerken

ook in Java 9 is het een beetje makkelijk:

List<String> list = List.of("element 1", "element 2", "element 3");

Antwoord 17

Je kunt het ook doen met stream in Java 8.

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

Antwoord 18

1. Als we de definitie van de methode Arrays.asList()zien, krijg je zoiets als dit:

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

   Dus je zou arraylistals volgt kunnen initialiseren:

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

   Opmerking: elk new Element(int args)wordt behandeld als een individueel object en kan worden doorgegeven als een var-args.

2. Misschien is er ook een ander antwoord op deze vraag.
   Als je een verklaring ziet voor de methode java.util.Collections.addAll(), krijg je zoiets als dit:

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

   Dus deze code is ook handig om dit te doen

   Collections.addAll(arraylist, array);
   

Antwoord 19

Een andere eenvoudige manier is om alle elementen van de array toe te voegen aan een nieuwe ArrayList met behulp van een for-each-lus.

ArrayList<Element> list = new ArrayList<>();
for(Element e : array)
    list.add(e);

Antwoord 20

Als de array van een primitief type is, werken de gegeven antwoorden niet. Maar sinds Java 8 kun je het volgende gebruiken:

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

Antwoord 21

Hoewel er veel perfect geschreven antwoorden op deze vraag zijn, zal ik mijn input toevoegen.

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

Nieuwe arrayclist kan op de volgende manieren worden gemaakt

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);

en ze ondersteunen heel goed alle operaties van arrayclist

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

Maar de volgende bewerkingen retourneren slechts een lijstweergave van een arrayclist en geen echte arrayclist.

// 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));

Daarom geven ze een foutmelding wanneer u probeert een aantal arraylist-operaties te maken

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

Meer op lijstvertegenwoordiging van array link .

Antwoord 22

De eenvoudigste manier om dit te doen is door de volgende code toe te voegen. Beproefd en getest.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

Antwoord 23

Nog een JAVA8-oplossing (ik heb misschien het antwoord gemist onder de grote set. Zo ja, mijn excuses). Hiermee maakt u een arrayclist (in tegenstelling tot een lijst), dwz men kan elementen

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);
    }
}

Uitgang is …
Hallo
wereld

Antwoord 24

U kunt het als volgt in Java 8 doen

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

Antwoord 25

We kunnen eenvoudig een array converteren naar arraylist.
We gebruiken de Incass-interface’s addAll()-methode voor het kopiëren van inhoud van de ene lijst naar het andere.

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

Antwoord 26

Gebruik de volgende code om een elementarray om te zetten in een ArrayList.

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}

Antwoord 27

Gegeven objectarray:

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

Array converteren naar lijst:

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

Array converteren naar ArrayList

   ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

Array converteren naar LinkedList

   LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

Lijst afdrukken:

   list.forEach(element -> {
        System.out.println(element.i);
    });

UITVOER

1

2

3

Antwoord 28

Heeft u al iedereen voldoende goed antwoord gegeven voor uw probleem.
Nu, van de alle suggesties, moet u besloten die bij uw vereiste past. Er zijn twee soorten verzameling die u moet weten. Eén is ongemodificeerde verzameling en andere verzameling waarmee u het object later kunt wijzigen.

Dus, hier zal ik een tekort aan twee gebruiksgevallen geven.

• Onbewuste Collection Creation :: Wanneer u het verzamelobject na de oprichting

  niet wilt wijzigen

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

• Collection Collection Collection :: Wanneer u het gemaakte verzamelobject na de oprichting mogelijk wilt wijzigen.

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

Antwoord 29

Arrays Class van Java 8 biedt een methode met een stroom () met overbelaste versies die zowel primitieve arrays als objectarrays accepteren.

/**** Converting a Primitive 'int' Array to List ****/
int intArray[] = {1, 2, 3, 4, 5};
List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());
/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/
List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());
/**** Converting an 'Integer' Array to List ****/
Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());

ANTWOORD 30

Onderstaande code lijkt een leuke manier om dit te doen.

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