Given an array of type Element[]
:
Element[] array = {new Element(1), new Element(2), new Element(3)};
How do I convert this array into an object of type ArrayList<Element>
?
ArrayList<Element> arrayList = ???;
new ArrayList<>(Arrays.asList(array));
Given:
Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };
The simplest answer is to do:
List<Element> list = Arrays.asList(array);
This will work fine. But some caveats:
The list returned from asList has fixed size. So, if you want to be able to add or remove elements from the returned list in your code, you'll need to wrap it in a new ArrayList. Otherwise you'll get an UnsupportedOperationException. The list returned from asList() is backed by the original array. If you modify the original array, the list will be modified as well. This may be surprising.
Arrays.asList()
creates a java.util.Arrays.ArrayList
(static nested class in java.util.Arrays
), not a java.util.ArrayList
.
(old thread, but just 2 cents as none mention Guava or other libs and some other details)
If You Can, Use Guava
It's worth pointing out the Guava way, which greatly simplifies these shenanigans:
Usage
For an Immutable List
Use the ImmutableList
class and its of()
and copyOf()
factory methods (elements can't be null):
List<String> il = ImmutableList.of("string", "elements"); // from varargs
List<String> il = ImmutableList.copyOf(aStringArray); // from array
For A Mutable List
Use the Lists
class and its newArrayList()
factory methods:
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
Please also note the similar methods for other data structures in other classes, for instance in Sets
.
Why Guava?
The main attraction could be to reduce the clutter due to generics for type-safety, as the use of the Guava factory methods allow the types to be inferred most of the time. However, this argument holds less water since Java 7 arrived with the new diamond operator.
But it's not the only reason (and Java 7 isn't everywhere yet): the shorthand syntax is also very handy, and the methods initializers, as seen above, allow to write more expressive code. You do in one Guava call what takes 2 with the current Java Collections.
If You Can't...
For an Immutable List
Use the JDK's Arrays
class and its asList()
factory method, wrapped with a Collections.unmodifiableList()
:
List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));
Note that the returned type for asList()
is a List
using a concrete ArrayList
implementation, but it is NOT java.util.ArrayList
. It's an inner type, which emulates an ArrayList
but actually directly references the passed array and makes it "write through" (modifications are reflected in the array).
It forbids modifications through some of the List
API's methods by way of simply extending an AbstractList
(so, adding or removing elements is unsupported), however it allows calls to set()
to override elements. Thus this list isn't truly immutable and a call to asList()
should be wrapped with Collections.unmodifiableList()
.
See the next step if you need a mutable list.
For a Mutable List
Same as above, but wrapped with an actual 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+
For Educational Purposes: 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);
}
List
returned by Arrays.asList
is mutable in that you can still set
elements - it just isn't resizable. For immutable lists without Guava you might mention Collections.unmodifiableList
.
Since this question is pretty old, it surprises me that nobody suggested the simplest form yet:
List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
As of Java 5, Arrays.asList()
takes a varargs parameter and you don't have to construct the array explicitly.
List<String> a = Arrays.asList("first","second","third")
new ArrayList<T>(Arrays.asList(myArray));
Make sure that myArray
is the same type as T
. You'll get a compiler error if you try to create a List<Integer>
from an array of int
, for example.
Another way (although essentially equivalent to the new ArrayList(Arrays.asList(array))
solution performance-wise:
Collections.addAll(arraylist, array);
Java 9
In Java 9, you can use List.of
static factory method in order to create a List
literal. Something like the following:
List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));
This would return an immutable list containing three elements. If you want a mutable list, pass that list to the ArrayList
constructor:
new ArrayList<>(List.of(// elements vararg))
JEP 269: Convenience Factory Methods for Collections
JEP 269 provides some convenience factory methods for Java Collections API. These immutable static factory methods are built into the List
, Set
, and Map
interfaces in Java 9 and later.
You probably just need a List, not an ArrayList. In that case you can just do:
List<Element> arraylist = Arrays.asList(array);
set
method), you cannot change the size of the list (not add
or remove
elements)!
Another update, almost ending year 2014, you can do it with Java 8 too:
ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));
A few characters would be saved, if this could be just a List
List<Element> list = Stream.of(myArray).collect(Collectors.toList());
Collectors.toList()
actually returns an ArrayList
.
If you use :
new ArrayList<T>(Arrays.asList(myArray));
you may create and fill two lists ! Filling twice a big list is exactly what you don't want to do because it will create another Object[]
array each time the capacity needs to be extended.
Fortunately the JDK implementation is fast and Arrays.asList(a[])
is very well done. It create a kind of ArrayList named Arrays.ArrayList where the Object[] data points directly to the array.
// 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
}
....
}
The dangerous side is that if you change the initial array, you change the List ! Are you sure you want that ? Maybe yes, maybe not.
If not, the most understandable way is to do this :
ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
list.add(element);
}
Or as said @glglgl, you can create another independant ArrayList with :
new ArrayList<T>(Arrays.asList(myArray));
I love to use Collections
, Arrays
, or Guava. But if it don't fit, or you don't feel it, just write another inelegant line instead.
new ArrayList<T>(Arrays.asList(myArray));
part which you discourage to use. Both do quite the same and have the same complexity.
new ArrayList<T>(Arrays.asList(myArray));
does the same, it copies the asList
to an ArrayList
...
In Java 9
you can use:
List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
According with the question the answer using java 1.7 is:
ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));
However it's better always use the interface:
List<Element> arraylist = Arrays.<Element>asList(array);
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray);
Since Java 8 there is an easier way to transform:
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());
}
You can convert using different methods
List
For more detail you can refer to http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html
as all said this will do so
new ArrayList<>(Arrays.asList("1","2","3","4"));
and the common newest way to create array is observableArrays
ObservableList: A list that allows listeners to track changes when they occur.
for Java SE you can try
FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));
that is according to Oracle Docs
observableArrayList() Creates a new empty observable list that is backed by an arraylist. observableArrayList(E... items) Creates a new observable array list with items added to it.
Update Java 9
also in Java 9 it's a little bit easy:
List<String> list = List.of("element 1", "element 2", "element 3");
You also can do it with stream in Java 8.
List<Element> elements = Arrays.stream(array).collect(Collectors.toList());
Collectors.toList()
will return an ArrayList
. However this may differ in future versions on java.If you want a specific type of collection then use Collectors.toCollection()
instead where you can specify which exact type of collection you would want to create.
If we see the definition of Arrays.asList() method you will get something like this: public static
If the array is of a primitive type, the given answers won't work. But since Java 8 you can use:
int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
char
array, either.
Another simple way is to add all elements from the array to a new ArrayList using a for-each loop.
ArrayList<Element> list = new ArrayList<>();
for(Element e : array)
list.add(e);
Even though there are many perfectly written answers to this question, I will add my inputs.
Say you have Element[] array = { new Element(1), new Element(2), new Element(3) };
New ArrayList can be created in the following ways
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);
And they very well support all operations of 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
But the following operations returns just a List view of an ArrayList and not actual ArrayList.
// 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));
Therefore, they will give error when trying to make some ArrayList operations
listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error
More on List representation of array link.
Simplest way to do so is by adding following code. Tried and Tested.
String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
Another Java8 solution (I may have missed the answer among the large set. If so, my apologies). This creates an ArrayList (as opposed to a List) i.e. one can delete elements
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);
}
}
Output is... Hello world
You can do it in java 8 as follows
ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
We can easily convert an array to ArrayList
. We use Collection interface's addAll()
method for the purpose of copying content from one list to another.
Arraylist arr = new Arraylist();
arr.addAll(Arrays.asList(asset));
ArrayList
s constructors accepts a ? extends Collection<T>
argument, making the call to addAll
redundant.
Use the following code to convert an element array into an 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]);
}
Given Object Array:
Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};
Convert Array to List:
List<Element> list = Arrays.stream(array).collect(Collectors.toList());
Convert Array to ArrayList
ArrayList<Element> arrayList = Arrays.stream(array)
.collect(Collectors.toCollection(ArrayList::new));
Convert Array to LinkedList
LinkedList<Element> linkedList = Arrays.stream(array)
.collect(Collectors.toCollection(LinkedList::new));
Print List:
list.forEach(element -> {
System.out.println(element.i);
});
OUTPUT
1
2
3
Already everyone has provided enough good answer for your problem. Now from the all suggestions, you need to decided which will fit your requirement. There are two types of collection which you need to know. One is unmodified collection and other one collection which will allow you to modify the object later.
So, Here I will give short example for two use cases.
Immutable collection creation :: When you don't want to modify the collection object after creation List
Mutable collection creation :: When you may want to modify the created collection object after creation. List
List
returned by Arrays.asList
is just a wrapper over the original array, and allows individual items to be accessed and modified via get
and set
. You should probably clarify that you mean "not add or remove elements" instead of "immutable", which means to not change at all.
Java 8’s Arrays class provides a stream() method which has overloaded versions accepting both primitive arrays and Object arrays.
/**** 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());
You could also use polymorphism to declare the ArrayList while calling the Arrays-interface as following:
List<Element> arraylist = new ArrayList<Integer>(Arrays.asList(array));
Example:
Integer[] array = {1}; // autoboxing
List<Integer> arraylist = new ArrayList<Integer>(Arrays.asList(array));
This should work like a charm.
Success story sharing
new ArrayList
call is unecessary as well.List<ClassName> list = Arrays.asList(array)
Arrays.asList(array)
without passing it into a newArrayList
object will fix the size of the list. One of the more common reasons to use anArrayList
is to be able to dynamically change its size, and your suggestion would prevent this.