Java Array to List

In Java programming, arrays and lists are basic data structures, typically used to store collections of elements. While arrays provide fixed-size storage, lists provide dynamic resizing and other functionality. There are times when we may need to convert arrays to a list for proper conversion or to be compatible with libraries that require a list. In this section, we explore various methods for converting Java arrays to lists, including examples and ideas for each method.

Converting Array to List in Java

Java array is a collection of multiple values of the same data type. An array can contain objects and primitive types. It depends on the definition of the array. If an array definition is of primitive type, the values of the array store in the contagious memory location. If an array contains objects elements, elements stored in the heap segment.

In Java, a List is an interface that belongs to the Java Collections framework. It stores elements in the form of objects in an ordered manner and preserves the insertion order. It allows us to store duplicate values. The classes ArrayList, LinkedList, Vector and Stack implements the List interface.

Java provides five methods to convert Array into a List are as follows:

Native Method
Using Arrays.asList() Method
Using Collections.addAll() Method
Using Java 8 Stream API
Using Guava Lists.newArrayList() Method

Native Method

It is the simplest method to convert Java Array into a List. In this method first, we create an empty List and add all the elements of the array into the List. Let's see an example.

ArrayToListExample1.java

import java.util.*; 
public class ArrayToListExample1
{ 
public static void main(String args[]) 
{ 
//creating an array 
String array[] = { "Golf", "Soccer", "Baseball", "Volleyball", "Tennis", "Badminton", "Rugby", "Archery", "Skiing"}; 
//prints the array before conversion
System.out.println("Array before conversion: "+ Arrays.toString(array)); 
//calling the generic function that converts Array into List
List<string> list = ArrayToListConversion(array); 
//print the List 
System.out.println("Array as List: " + list); 
}     
//creating a generic function that converts the Array into List
public static <t> List<t> ArrayToListConversion(T array[]) 
{ 
//creating the constructor of the List class
List<t> list = new ArrayList<>(); 
//using for-each loop to iterate over the array
for (T t : array) 
{ 
//adding each element to the List
list.add(t); 
} 
//returns the list converted into Array
return list; 
} 
}
</t></t></t></string>

Output:

Using Arrays.asList() Method

It is the method of the Java Arrays class that belongs to java.util package. When we use the asList() method with the Collection.toArray() method, it works as a bridge between array-based and collection-based APIs.

Syntax:

public static <t> List<t> asList(T... a)
</t></t>

The method parses an array as a parameter by which the list will be backed. It returns a serializable fixed-size list view of the specified array. Let's see an example.

ArrayToListExample2.java

import java.util.*; 
public class ArrayToListExample2
{ 
public static void main(String args[]) 
{ 
//creating an array to be converted
String arr[] = { "Aston Martin", "Bugatti", "Bentley", "Alfa Romeo", "Buick", "Acura", "Audi", "BMW", "Buick" }; 
//prints array before conversion
System.out.println("Array before conversion: "+ Arrays.toString(arr)); 
//calling generic method that converts Array into List
List<string> list = ArrayToListConversion(arr); 
//prints the List
System.out.println("Array after conversion: " + list); 
} 
//creating a generic function that converts the Array into List
public static <t> List<t> ArrayToListConversion(T arr[]) 
{ 
//invoking the asList() method and passing the array to be converted
List<t> list = Arrays.asList(arr); 
//returns the list
return list; 
} 
}
</t></t></t></string>

Output:

Using Collections.addAll() Method

It is the method of the Java Collections class. it belongs to java.util package. The class provides a method named addAll(). We can use the method to convert Array into a List. It adds all the elements to the specified collection. We can specify elements either individually or in the form of an array. It works the same as c.addAll(Arrays.asList(elements)). It is a faster implementation than another implementation.

Syntax:

It parses two parameters:

c: It is a collection in which elements are to be added.
elements: The elements are to be inserted into c.

It returns true if the collection changed as a result of the call. It throws the following exceptions:

If the parameter c does not support the add operation, it throws UnsupportedOperationException.
If the specified array elements contain one or more null values and c does not allow null elements, it throws NullPointerException.
If any array element prevents it from being added to the parameter c it throws IllegalPointerException.

Let's see an example.

ArrayToListExample3.java

import java.util.*; 
public class ArrayToListExample3
{ 
public static void main(String args[]) 
{ 
//creating an Array to be converted
String arr[] = { "San Jose", "Dallas", "Chicago","San Antonio", "Los Angeles", "Portland", "Tucson" }; 
//prints the Array 
System.out.println("Array before conversion: "+ Arrays.toString(arr)); 
//method calling
List<string> list = ArrayToListConversion(arr); 
//print the List 
System.out.println("Array after conversion: " + list); 
}     
//creating a generic function that converts the Array into List
public static <t> List<t> ArrayToListConversion(T arr[]) 
{ 
//creating the constructor of thr List class
List<t> list = new ArrayList<>(); 
//the method adds Array to the List
Collections.addAll(list, arr); 
//returns the list
return list; 
} 
}
</t></t></t></string>

Output:

Using Java 8 Stream API

Java 8 provides the Stream API to process the collections of objects. It is a sequence of methods that can be pipelined to produce the desired result. Remember that it does not change the original data structure. It provides the output based on the pipelined methods. We can attain Stream in a number of ways but in the following program, we have used Arrays.stream(Object[]) to attain the stream.

Collectors.toList() Method: The method returns a Collector that collects the input elements into a newly created List in an encounter method.

Syntax:

Where T is the type of element that we have specified. The method does not provide guarantees on type, mutability, thread-safety, and serializability.

Let's use the Stream API in a Java program and convert an array into a List.

ArrayToListExample4.java

import java.util.*; 
import java.util.stream.Collectors;
public class ArrayToListExample4
{ 
//creating a generic function that converts the Array into List
public static <t> List<t> ArrayToListConversion(T arr[]) 
{ 
//creates a list from the specified Array and returns the List
return Arrays.stream(arr).collect(Collectors.toList()); 
} 
public static void main(String args[]) 
{ 
//creating an array to be converted into List
String arr[] = { "Python", "HTM", "Java", "C", "C++", "JavaScript", "Ruby", "Swift", "PHP" }; 
//prints the Array before conversion
System.out.println("Array: "+ Arrays.toString(arr)); 
//calling the method created above and storing the elements into the List object
List<string> list = ArrayToListConversion(arr); 
//prints the List 
System.out.println("List: " + list); 
} 
} 
</string></t></t>

Output:

Using Guava Lists.newArrayList()

It is the method of the Lists class that belong to com.google.common.collect package. The class provides a method newArrayList() that creates mutable empty ArrayList instance having the elements of the specified array.

Syntax:

public static <e> ArrayList<e> newArrayList(E... elements)
</e></e>

Note: The newArrayList() method is available for Java 6 and earlier versions. In later versions it is deprecated. Instead of the above method, we use ArrayList constructor directly.

ArrayToListExample5.java

import static com.google.common.collect.Lists.*; 
import java.util.*; 
public class ArrayToListExample5
{ 
public static void main(String args[]) 
{ 
//creating an Array to be converted into a List
String arr[] = { "Mango", "Banana", "Grapes",  "Apple", "Plum", "Blackberry", "Papaya", "Orange" }; 
//prints the Array before conversion
System.out.println("Array: "+ Arrays.toString(arr)); 
//convert the Array to List 
List<string> list = ArrayToListConversion(arr); 
//prints the List 
System.out.println("List: " + list); 
}
//creating a generic function that converts the Array into List
public static <t> List<t> ArrayToListConversion(T arr[]) 
{ 
//creates a List from the specified Array 
return Lists.newArrayList(arr); 
} 
}
</t></t></string>

Output:

Considerations

When converting arrays to lists, it's essential to consider the following points:

Mutability: Arrays.asList() returns a fixed-size list, while the other methods create mutable lists. Choose the appropriate method based on whether we need a mutable or immutable list.

Performance: Arrays.asList() provides a view of the original array, so it's efficient in terms of memory usage. However, if we need a mutable list, consider using ArrayList or streams.

Null Elements: Be cautious when dealing with arrays that contain null elements, as some methods might throw NullPointerException.

Primitive Arrays: For primitive arrays (like int[], double[]), we cannot directly use Arrays.asList(). In such cases, we will need to use wrapper classes or manual conversion.

Conclusion

Modifying lists of Java arrays is a common programming task, and Java provides many ways to do this efficiently. Whether you need a fixed-size or variable list, there is a convenient option. Understanding the differences between these methods will help you choose the most appropriate method for your application, taking into account your specific needs.

Next TopicJIT in Java

← prev next →