Vraag Maak ArrayList van array


Ik heb een array die is geïnitialiseerd zoals:

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

Ik zou deze array willen omzetten in een object van de klasse ArrayList.

ArrayList<Element> arraylist = ???;

2963
2017-10-01 14:38


oorsprong


antwoorden:


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

3962
2017-10-01 14:39



Gegeven:

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

Het eenvoudigste antwoord is om te doen:

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

Dit werkt prima. Maar enkele kanttekeningen:

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

774
2017-10-01 15:39



(oude draad, maar slechts 2 cent zoals niemand Guava of andere libs en wat andere details noemt)

Als je kunt, gebruik Guava

Het is de moeite waard om op Guava te wijzen, wat deze shenanigans enorm vereenvoudigt:

Gebruik

Voor een onveranderlijke lijst

Gebruik de ImmutableList klasse en zijn of() en copyOf() fabrieksmethoden (elementen mogen niet nul 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 te verminderen door generieke medicijnen voor type-veiligheid, zoals het gebruik van de Guava fabrieksmethoden laat de typen meestal afleiden. Dit argument bevat echter minder water omdat Java 7 bij de nieuwe diamantoperator arriveerde.

Maar het is niet de enige reden (en Java 7 is nog niet overal): de syntaxis voor steno's is ook erg handig, en de methode-initializers, zoals hierboven te zien, maken het mogelijk om meer expressieve code te schrijven. Je doet in één Guava-call wat 2 kost met de huidige Java-collecties.


Als je niet kunt ...

Voor een onveranderlijke lijst

Gebruik de JDK's Arrays klasse en zijn asList() fabrieksmethode, omwikkeld 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() is een List met behulp van een beton ArrayList implementatie, maar Het is niet  java.util.ArrayList. Het is een innerlijk type, dat een emuleert ArrayList maar verwijst in feite direct naar de doorgelaten array en maakt deze "doorschrijf" (wijzigingen worden weerspiegeld in de array).

Het verbiedt aanpassingen via enkele van de List API's methoden door simpelweg een AbstractList (dus wordt het toevoegen of verwijderen van elementen niet ondersteund), maar hiermee kunnen wel oproepen worden gedaan set() elementen overschrijven. Dus deze lijst is niet echt onveranderlijk en een oproep tot asList() moet worden ingepakt 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: The Good ol 'Manual Way

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

295
2017-11-16 17:16



Aangezien deze vraag vrij oud is, verbaast het mij dat niemand de eenvoudigste vorm tot nu toe heeft voorgesteld:

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

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


203
2018-06-22 11:30



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

Zeker weten dat myArray is van hetzelfde type als T. U krijgt een compileerfout als u probeert een te maken List<Integer>uit een reeks van int, bijvoorbeeld.


172
2017-10-01 14:40



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

Collections.addAll(arraylist, array);

77
2018-04-03 23:20



Je hebt waarschijnlijk alleen een lijst nodig, geen ArrayList. In dat geval kun je gewoon doen:

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

62
2017-10-01 14:45