Java How to Convert Array to List with Examples

You can convert an array to a list in Java using Arrays.asList(array), which returns a fixed-size list backed by the array.

Examples

Input["apple", "banana", "cherry"]

Output[apple, banana, cherry]

Input[1, 2, 3, 4]

Output[1, 2, 3, 4]

Input[]

Output[]

How to Think About It

To convert an array to a list, think of wrapping the array inside a list structure without copying elements manually. Java provides a built-in method Arrays.asList() that takes the array and returns a list view of it.

Algorithm

1

Get the input array.

2

Use the built-in method <code>Arrays.asList()</code> with the array as argument.

3

Return the resulting list.

Code

java

import java.util.Arrays;
import java.util.List;

public class ArrayToListExample {
    public static void main(String[] args) {
        String[] fruits = {"apple", "banana", "cherry"};
        List<String> fruitList = Arrays.asList(fruits);
        System.out.println(fruitList);
    }
}

Output

[apple, banana, cherry]

Dry Run

Let's trace converting the array ["apple", "banana", "cherry"] to a list.

1

Input array

fruits = ["apple", "banana", "cherry"]

2

Convert using Arrays.asList

fruitList = Arrays.asList(fruits) -> [apple, banana, cherry]

3

Print the list

Output: [apple, banana, cherry]

Step	Action	Value
1	Input array	["apple", "banana", "cherry"]
2	Convert to list	[apple, banana, cherry]
3	Print list	[apple, banana, cherry]

Why This Works

Step 1: Arrays.asList creates a list view

The method Arrays.asList() wraps the array into a fixed-size list without copying elements.

Step 2: List reflects array changes

Changes to the array will reflect in the list and vice versa because they share the same data.

Step 3: List size is fixed

You cannot add or remove elements from the list returned by Arrays.asList() because its size is fixed.

Alternative Approaches

Using ArrayList constructor

java

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

public class ArrayToListAlt {
    public static void main(String[] args) {
        String[] fruits = {"apple", "banana", "cherry"};
        List<String> fruitList = new ArrayList<>(Arrays.asList(fruits));
        System.out.println(fruitList);
    }
}

This creates a modifiable list, allowing add/remove operations unlike Arrays.asList.

Using Java 8 Streams

java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class ArrayToListStream {
    public static void main(String[] args) {
        String[] fruits = {"apple", "banana", "cherry"};
        List<String> fruitList = Arrays.stream(fruits).collect(Collectors.toList());
        System.out.println(fruitList);
    }
}

Streams provide a flexible way to convert arrays to lists and allow further processing.

Complexity: O(n) time, O(1) or O(n) depending on method space

Time Complexity

Converting an array to a list takes O(n) time because each element is referenced or copied once.

Space Complexity

Using Arrays.asList() uses O(1) extra space as it wraps the array, but creating a new ArrayList copies elements, using O(n) space.

Which Approach is Fastest?

Arrays.asList() is fastest and uses least memory but returns a fixed-size list. Creating a new ArrayList is slower but allows modification.

Approach	Time	Space	Best For
Arrays.asList()	O(n)	O(1)	Quick conversion, fixed-size list
new ArrayList<>(Arrays.asList())	O(n)	O(n)	Modifiable list
Streams with Collectors.toList()	O(n)	O(n)	Flexible processing and modifiable list