Create ArrayList from array

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:

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.

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

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

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

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

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.

Below code seems nice way of doing this.

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

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

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 = Arrays.stream(array).collect(Collectors.toList());

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);                   
   System.out.println(list);
   

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);
    System.out.println(list1);
   

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) {
        list2.add(text);
    }
    System.out.println(list2);
   

you can refer this document too

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) {
     list2.add(text);
  }

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) {
            convertedArray.add(element);
        }

        return convertedArray;
    }

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

With Stream (since java 16)

new ArrayList<>(Arrays.stream(array).toList());

I've used the following helper method on occasions when I'm creating a ton of ArrayLists and need terse syntax:

import java.util.ArrayList;
import java.util.Arrays;

class Main {

    @SafeVarargs
    public static <T> ArrayList<T> AL(T ...a) {
        return new ArrayList<T>(Arrays.asList(a));
    }

    public static void main(String[] args) {
        var al = AL(AL(1, 2, 3, 4), AL(AL(5, 6, 7), AL(8, 9)));
        System.out.println(al); // => [[1, 2, 3, 4], [[5, 6, 7], [8, 9]]]
    }
}

Guava uses the same approach so @SafeVarargs appears to be safe here. See also Java SafeVarargs annotation, does a standard or best practice exist?.

Use below code

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

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

List<Element> list = List.of(array);

or

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

both ways we can convert it to a list.