Create ArrayList from array

Created 01.10.2008 14:38
Viewed 1.58M times
3784 votes

I have an array that is initialized like:

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

I would like to convert this array into an object of the ArrayList class.

ArrayList<Element> arraylist = ???;
In Java9 --> List<String> list = List.of(“Hello”, “World”, “from”, “Java”); by MarekM, 11.04.2017 12:18
@MarekM This answer is wrong, as this doesn't return an ArrayList. The Poster asked specifically for that. by Dorian Gray, 12.10.2017 06:28
I think he didn't mine using List interface, because it is best practice. But if you want here is - new ArrayList<>(List.of(“Hello”, “World”, “from”, “Java”)); by MarekM, 17.10.2017 12:09
The point is not about using the interface, the point is that in your solution, the returned list is unmodifiable. That might be more of a problem, and a reason why he asked for an ArrayList by Dorian Gray, 03.08.2018 20:59
Answers 41
new ArrayList<>(Arrays.asList(array));
01.10.2008 14:39
Yep. And in the (most common) case where you just want a list, the new ArrayList call is unecessary as well. by Calum, 01.10.2008 14:41
@Luron - just use List<ClassName> list = Arrays.asList(array) by Pool, 29.06.2011 15:18
@Calum and @Pool - as noted below in Alex Miller's answer, using Arrays.asList(array) without passing it into a new ArrayList object will fix the size of the list. One of the more common reasons to use an ArrayList is to be able to dynamically change its size, and your suggestion would prevent this. by Code Jockey, 26.09.2011 19:04
I'd like to point out that the new ArrayList<Element>(...) part is necessary if you want to perform mutative (like remove) operations with an iterator. by markbaldy, 23.11.2012 05:28
Arrays.asList() is a horrible function, and you should never just use its return value as is. It breaks the List template, so always use it in the form indicated here, even if it does seem redundant. Good answer. by Adam, 23.01.2013 03:28
A caveat: I just run into a misbehavior of Java 6: when Element is a primitive (e.g. the array is int[]), asList creates List<int[]> . by User, 20.02.2013 15:48
@Adam Arrays.asList() is a very useful method when you want a list backed by a specific array. For example Collections.shuffle(Arrays.asList(myarray)) shuffles the original array. by lbalazscs, 21.02.2013 21:13
@lbalazscs true, but I would say that's pretty close to a hack (even if the shuffle method was intended to be used that way), because you're basically tricking it into thinking it's dealing with a List when it's not. Handy, but I still say it's a horrible function. My argument is basically that the asList() method is misleading because it looks like it returns a List representation of the given array, when in fact it returns an only-partially-implemented List representation. by Adam, 22.02.2013 05:08
@Adam Please study the javadoc for java.util.List. The contract for add allows them to throw an UnsupportedOperationException.… Admittedly, from an object-oriented perspective it is not very nice that many times you have to know the concrete implementation in order to use a collection - this was a pragmatic design choice in order to keep the framework simple. by lbalazscs, 22.02.2013 09:41
@Arkadiy It is not a misbeavior that Arrays.asList(a).get(0) == a when a is an int[]. This is because of how the asList(Object...) varargs resolve. An object of type int[] is an Object, not an Object[], so Arrays.asList is being passed an array of Object with one element: an array of int. by AndrewF, 13.03.2013 06:18
@AndrewF I understand why this happens. It's just breaking DWIM for me, is all. by User, 15.03.2013 13:57
This doesn't compile when array is of type int[] and the equivalent usecase is like so: List<Integer> intList = new ArrayList<Integer>(Arrays.asList(intArray)); by tuxdna, 08.07.2013 07:09
Arrays.asList(array).remove(key) will throw:Exception in thread "main" java.lang.UnsupportedOperationException at java.util.AbstractList.remove( at ... - dunno how AbstractList got in there but you do not want it around when calling remove by Mr_and_Mrs_D, 09.04.2014 23:55
For the case when the array is of a primitive type like int[] see this question and answers:… by RenniePet, 28.02.2015 09:24
On a side note, List<Element> list = new ArrayList<>(Arrays.asList(array)); would've sufficed. The diamond operator will do the type inference for you. by Srini, 27.05.2015 14:09
@Mr_and_Mrs_D Probably because the list returned by Arrays.asList is of a class that inherits from AbstractList and doesn't implement remove (which is because you can't remove stuff from an array) by user253751, 01.10.2015 02:34
This does not work for Java 1.8. In Java 1.8, Arrays.asList(array) will create a list whose only element is array. The resulted list does not contain array's elements. by Jingguo Yao, 30.12.2016 09:08
Something I just found out (for open jdk at least) is that Arrays.asList(array) creates a lightweight list wrapper around the array but the corresponding toArray call creates a new copy of the array. The call to new ArrayList(Collection) calls this toArray method and then creates another defensive copy, which means one additional array allocation. You can avoid all these by using Lists.newArrayList in guava or create new ArrayList(array.length) and then copy all the elements across. by muzzlator, 29.11.2017 01:10
With Java 9 you should use java.util.List.of(array) which gives you an immutable list (instance of internal class AbstractImmutableList). You can use new ArrayList<>(List.of(array)) if you need a modifiable list. see List by Datz, 27.03.2018 06:45
Show remaining 14 comments


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:

  1. 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.
  2. 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.
01.10.2008 15:39
What is the time complexity of both operations? I mean with and without using explicit arraylist construction. by damned, 23.05.2012 02:17
Arrays.asList() merely creates an ArrayList by wrapping the existing array so it is O(1). by Alex Miller, 23.05.2012 13:15
Wrapping in a new ArrayList() will cause all elements of the fixed size list to be iterated and added to the new ArrayList so is O(n). by Alex Miller, 23.05.2012 13:21
the implementation of List returned by asList() does not implement several of List's methods (like add(), remove(), clear(), etc...) which explains the UnsupportedOperationException. definitely a caveat... by sethro, 14.11.2012 19:33
When the question asks for "an object of the ArrayList class" I think it's reasonable to assume the class it refers to is java.util.ArrayList. Arrays.asList actually returns a java.util.Arrays.ArrayList which is not an instanceof the other class. So a third caveat is that if you try to use it in a context requiring the above it will not work. by Dave L., 24.06.2016 19:16
For those curious and frustrated like I was regarding first caveat about fixed size List: If you drop down to Arrays.asList implementation you'll see that it returns new ArrayList<>(a). Might seem that it's an ordinary ArrayList. But don't make hasty conclusions - if you scroll just a lil bit down in you'll see a private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, This is just an internal class which is a collection, but NOT a true java.util.ArrayList. Just the same class names. by Dmitriy Fialkovskiy, 05.08.2019 11:30
Show remaining 1 comments

(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:


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) {
  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++) {
  return (l);
16.11.2012 17:16
+1 But note that the 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. by Paul Bellora, 10.01.2013 02:54
@haylem In your section For Educational Purposes: The Good ol' Manual Way, your arrayToList for Java 1.5+ is incorrect. You are instanciating lists of String, and trying to retrieve strings from the given array, instead of using the generic parameter type, T. Other than that, good answer, and +1 for being the only one including the manual way. by afsantos, 16.05.2013 13:41
Id' rename your section "If You Can't... / For an Immutable List" to "For an unmodifiable List" as it can be mutated by later changes to the wrapped array. It's still O(1), but for immutability you have to make a copy, e.g., by Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))). by maaartinus, 19.11.2019 09:35
You should not use a 3rd party library when there are viable alternatives within java. Reasons: you increase the chance of bugs brought in by the 3rd party library, you increase your attack surface area for potential hackers. Guava itself is overengineered. by marathon, 01.05.2021 18:04
@marathon: All fair points (+1), but: a/ This answer is 9 years old (aoutch!), so bear in mind that a things have changed a bit since. Java 8 was barely on the horizon then. b/ In many cases, a good library is likely to be less buggy than your own code, as it will have benefited from more eyeballs to pick at all its scabs. c/ Guava isn't that heavy, and I wouldn't call it over-engineered. It's rather well engineered and simple, but it's true you might not need all of it. d/ I did provide a vanilla Java way (for back then's Java, of course), as indeed I also agree a library isn't always needed. by haylem, 14.05.2021 08:56

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.

22.06.2011 11:30
In particular, List<String> a = Arrays.asList("first","second","third") by 18446744073709551615, 12.07.2016 15:29
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.

01.10.2008 14:40
In case of int to List<Integer>: List<Integer> ILst = myarray ).boxed().collect(Collectors.toList()); by Abdelmonem Mahmoud Amer, 02.05.2021 08:16

Another way (although essentially equivalent to the new ArrayList(Arrays.asList(array)) solution performance-wise:

Collections.addAll(arraylist, array);
03.04.2012 23:20

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.

17.04.2016 16:58
List.of() will not return an instance of java.util.ArrayList, as requested in the original question. Therefore only the second option is a valid answer. by tquadrat, 05.07.2019 12:31

You probably just need a List, not an ArrayList. In that case you can just do:

List<Element> arraylist = Arrays.asList(array);
01.10.2008 14:45
That will be backed by the original input array, which is why you (probably) want to wrap it in a new ArrayList. by Bill the Lizard, 01.10.2008 14:46
Be careful with this solution. If you look, Arrays ISN'T returning a true java.util.ArrayList. It's returning an inner class that implements the required methods, but you cannot change the memebers in the list. It's merely a wrapper around an array. by Mikezx6r, 01.10.2008 14:47
You can cast the List<Element> item to an ArrayList<Element> by monksy, 09.10.2009 22:48
@Mikezx6r: little correction: it's a fixed-size list. You can change the elements of the list (set method), you cannot change the size of the list (not add or remove elements)! by user85421, 04.12.2009 13:10
Yes, with the caveat that it depends on what you want to do with the list. It's worth notng that if the OP simply wants to iterate through the elements, the array doesn't have to be converted at all. by PaulMurrayCbr, 05.05.2013 09:23
@monksy No, you can't. As was said, it is a different kind of ArrayList. by glglgl, 22.02.2015 17:05
This does not work if array element is of primitive type in Java 8. For details, see by Jingguo Yao, 04.02.2016 07:05
Show remaining 2 comments

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());
25.11.2014 20:48
It's probably best not to be implementation-dependent, but Collectors.toList() actually returns an ArrayList. by bcsb1001, 31.12.2014 19:55
incorrect use of Stream.of(...); that will create a one element stream. Use instead by Patrick Parker, 18.11.2016 11:59
I don't think so, the 2 options are valid but the is slightly 'better' since you can create it with fixed size, using the overload method with 'start', 'end' args. See also: by yamilmedina, 30.11.2016 21:45

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

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.

18.01.2014 13:01
I fail to see the fundamental difference between your loop at the end of the answer and the new ArrayList<T>(Arrays.asList(myArray)); part which you discourage to use. Both do quite the same and have the same complexity. by glglgl, 22.02.2015 17:03
The Collections one create a pointer at the beginning of the array. My loop create many pointers : one for each array member. So if the original array changes, my poiners are still directed toward the former values. by Nicolas Zozol, 22.02.2015 19:59
new ArrayList<T>(Arrays.asList(myArray)); does the same, it copies the asList to an ArrayList... by glglgl, 22.02.2015 21:56

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);
11.04.2017 12:20
Note that this is not an ArrayList, as it was explicitely asked. by Dorian Gray, 03.08.2018 20:57

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);
17.05.2015 22:07
// Guava
List<String> list = Lists.newArrayList(aStringArray); 
07.01.2014 06:04

Since Java 8 there is an easier way to transform:

import java.util.List;    
import static;

public static <T> List<T> fromArray(T[] array) {
23.12.2016 12:31

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");
05.01.2017 18:32

You can convert using different methods

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

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

  3. Arraylist list = new Arraylist();

For more detail you can refer to

02.05.2016 08:40

You also can do it with stream in Java 8.

 List<Element> elements =; 
06.02.2016 08:56
As of java 8, 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. by Raja Anbazhagan, 04.02.2019 11:08
  1. If we see the definition of Arrays.asList() method you will get something like this:

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

    So, you might initialize arraylist like this:

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

    Note : each new Element(int args) will be treated as Individual Object and can be passed as a var-args.

  2. There might be another answer for this question too.
    If you see declaration for java.util.Collections.addAll() method you will get something like this:

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

    So, this code is also useful to do so

    Collections.addAll(arraylist, array);
30.03.2016 06:48

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)
16.12.2015 20:32

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];;
10.07.2017 02:21
this solution doesn't seem to work with char array, either. by PixelMaster, 10.06.2018 19:55

You can do it in java 8 as follows

ArrayList<Element> list = (ArrayList<Element>);
07.06.2017 12:14
Downvoted because that cast looks very dangerous. nothing specifies that the type of list that is returned is actually an ArrayList, as the javadoc states: "There are no guarantees on the type, mutability, serializability, or thread-safety of the List returned" by Dorian Gray, 03.07.2018 17:45
If you want to explicitely create an ArrayList, try this: ArrayList<String> list =‌​st::new)); by Dorian Gray, 03.08.2018 20:53

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;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)

    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

Output is...

20.06.2017 08:33

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));
03.05.2017 08:38

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();
04.07.2017 07:22
This is less efficient than the accepted 9 year old answer. by charles-allen, 10.07.2017 10:06
One of ArrayLists constructors accepts a ? extends Collection<T> argument, making the call to addAll redundant. by Tamoghna Chowdhury, 06.10.2017 20:26

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.

07.04.2017 18:45

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++) {
03.12.2018 11:32

There is another option if your goal is to generate a fixed list at runtime, which is as simple as it is effective:

static final ArrayList<Element> myList = generateMyList();

private static ArrayList<Element> generateMyList() {
  final ArrayList<Element> result = new ArrayList<>();
  result.add(new Element(1));
  result.add(new Element(2));
  result.add(new Element(3));
  result.add(new Element(4));
  return result;

The benefit of using this pattern is, that the list is for once generated very intuitively and therefore is very easy to modify even with large lists or complex initialization, while on the other hand always contains the same Elements on every actual run of the program (unless you change it at a later point of course).

04.10.2013 21:50
This doesn't answer the original question. The OP already has the elements in a container, which we can assume has random contents. This approach depends on the list needing the exact same elements every time this code is run. Also, the overuse of the static keyword is bad practice, and there are many other ways of doing this in practice which involve less boilerplate code. by Shotgun Ninja, 08.04.2015 15:17

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

/**** 'IntStream.of' or '' 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 =;
19.05.2019 11:20

Given Object Array:

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

Convert Array to List:

    List<Element> list =;

Convert Array to ArrayList

    ArrayList<Element> arrayList =

Convert Array to LinkedList

    LinkedList<Element> linkedList =

Print List:

    list.forEach(element -> {





07.09.2019 20:36

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<Element> elementList = Arrays.asList(array)

  • Mutable collection creation :: When you may want to modify the created collection object after creation.

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

25.07.2017 06:03
List<Element> elementList = Arrays.asList(array) creates a wrapper over the original array which makes original array available as List. Hence a wrapper object is created, nothing gets copied from the original array. Therefore, operations like add or remove elements are not allowed. by Priyanka, 09.09.2017 08:57
Note that your "immutable collection" is not really immutable - the 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. by Tamoghna Chowdhury, 06.10.2017 20:24

You can create an ArrayList using Cactoos (I'm one of the developers):

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"

There is no guarantee that the object will actually be of class ArrayList. If you need that guarantee, do this:

ArrayList<String> list = new ArrayList<>(
  new StickyList<>(
    "Scott Fitzgerald", "Fyodor Dostoyevsky"
26.06.2017 12:19
I respect your work. But as someone new to Java, List and rest of its collections (ArrayList, etc...) is already too much to handle. Why you want me to suffer more :-( by Suhaib, 30.06.2017 20:44

Below code seems nice way of doing this.

new ArrayList<T>(Arrays.asList(myArray));
04.12.2019 07:59

For normal size arrays, above answers hold good. In case you have huge size of array and using java 8, you can do it using stream.

  Element[] array = {new Element(1), new Element(2), new Element(3)};
  List<Element> list =;
18.11.2020 12:45

the lambda expression that generates a list of type ArrayList<Element>
(1) without an unchecked cast
(2) without creating a second list (with eg. asList())

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

02.08.2019 05:50

Use below code

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> list = (ArrayList) Arrays.asList(array);
28.03.2019 11:42

Use below script

Object[] myNum = {10, 20, 30, 40};
List<Object> newArr = new ArrayList<>(Arrays.asList(myNum));
31.07.2020 06:09

In java there are mainly 3 methods to convert an array to an arrayList

  1. Using Arrays.asList() method : Pass the required array to this method and get a List object and pass it as a parameter to the constructor of the ArrayList class.

    List<String> list = Arrays.asList(array);                   
  2. Collections.addAll() method - Create a new list before using this method and then add array elements using this method to existing list.

     List<String> list1 = new ArrayList<String>();
     Collections.addAll(list1, array);
  3. Iteration method - Create a new list. Iterate the array and add each element to the list.

     List<String> list2 = new ArrayList<String>();
     for(String text:array) {

you can refer this document too

24.09.2020 11:27

There is one more way that you can use to convert the array into an ArrayList. You can iterate over the array and insert each index into the ArrayList and return it back as in ArrayList.

This is shown below.

public static void main(String[] args) {
        String[] array = {new String("David"), new String("John"), new String("Mike")};

        ArrayList<String> theArrayList = convertToArrayList(array);

    private static ArrayList<String> convertToArrayList(String[] array) {
        ArrayList<String> convertedArray = new ArrayList<String>();

        for (String element : array) {

        return convertedArray;
17.11.2020 03:39

This is the first and the easiest method

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

Another method

//declare myarray
ArrayList <String> ar = new ArrayList<String> ();
for(String s : myArray){

This is iterating through the array and adding each element separately

The kind of for loop used here is called enhanced for loop

02.06.2020 17:13

Hi you can use this line of code , and it's the simplest way

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

or in case you use Java 9 you can also use this method:

List<String> list = List.of("Hello", "Java"); 
List<Integer> list = List.of(1, 2, 3);
06.07.2020 08:13

You can use the following 3 ways to create ArrayList from Array.

  String[] array = {"a", "b", "c", "d", "e"};

  //Method 1
  List<String> list = Arrays.asList(array);          

  //Method 2
  List<String> list1 = new ArrayList<String>();
  Collections.addAll(list1, array);

  //Method 3
  List<String> list2 = new ArrayList<String>();
  for(String text:array) {
21.10.2020 04:24