Java Convert Array to Collection

In Java, changing an array to a collection may be finished using diverse techniques supplied by way of the Java Collections Framework. The Collections Framework presents a hard and fast of interfaces and training to manipulate collections of objects. To convert an array to a set, you may comply with those steps:

Create an array of any type and populate it with factors.

Use the Arrays.asList() method to transform the array to a List series.

Note that Arrays.asList() returns a fixed-length list backed by way of the unique array. Any modifications to the listing will without delay have an effect on the array and vice versa.

If we want a different type of series, which includes a Set or Queue, we could create a new series and skip the array as a parameter to the constructor.

Here, the HashSet constructor accepts a Collection as a parameter, so we skip the end result of Arrays.AsList().

If we require a mutable collection that may be modified independently from the authentic array, we can create a new instance of the desired collection kind and add the factors separately.

List<String> mutableList = new ArrayList<>();
Collections.addAll(mutableList, array);

The Collections.addAll() approach lets in you to feature the elements of an array to a set.

If we choose to use a general series type, along with Collection or Iterable, we can use the Arrays.stream() approach in aggregate with the collect() method to transform the array.

Collection<String> collection = Arrays.stream(array).collect(Collectors.toList());

Here, Arrays.movement() converts the array to a flow of factors, and acquire() collects the factors right into a List using the Collectors.toList() collector.

Using the Apache Commons Collections library: If we have got Apache Commons Collections library brought in your task, we can use the CollectionUtils.addAll() approach to feature array factors to a group.

ArrayToCollectionExample.java

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.ArrayUtils;
import java.util.ArrayList;
import java.util.List;
public class ArrayToCollectionExample {
    public static void main(String[] args) {
        // Sample array of integers
        Integer[] intArray = {1, 2, 3, 4, 5};
        // Convert array to a List using Apache Commons Collections
        List<Integer> integerList = new ArrayList<>();
        CollectionUtils.addAll(integerList, intArray);
        // Print the elements of the list
        for (Integer num : integerList) {
            System.out.println(num);
        }
    }
}

Output:

Using Java 8 streams: Java 8 brought the Stream API, which offers powerful practical-fashion operations on collections. You can convert an array to a group the usage of streams as follows:

ArrayToCollectionExample.java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class ArrayToCollectionExample {
    public static void main(String[] args) {
        // Sample array of integers
        Integer[] intArray = {1, 2, 3, 4, 5};
        // Convert array to a List using Java 8 streams
        List<Integer> integerList = Arrays.stream(intArray).collect(Collectors.toList());                                
        // Print the elements of the list
        for (Integer num : integerList) {
            System.out.println(num);
        }
    }
}

Output:

This technique permits you to take benefit of numerous movement operations like filtering, mapping, and sorting if wanted.

Converting to an unmodifiable series: If we need to create an unmodifiable series, we can wrap the transformed series the usage of Collections.UnmodifiableCollection() or Collections.UnmodifiableList() techniques.

ArrayToUnmodifiableCollectionExample.java

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
public class ArrayToUnmodifiableCollectionExample 
    public static void main(String[] args) {
        // Sample array of integers
        Integer[] intArray = {1, 2, 3, 4, 5};
        // Convert array to an unmodifiable collection
        Collection<Integer> unmodifiableCollection = Collections.unmodifiableCollection(Arrays.asList(intArray));
        // Attempting to modify the unmodifiable collection will result in an UnsupportedOperationException
        try {
            unmodifiableCollection.add(6); // Trying to add an element
        } catch (UnsupportedOperationException e) {
            System.out.println("Error: " + e.getMessage());
        }
        // Print the elements of the unmodifiable collection
        for (Integer num : unmodifiableCollection) {
            System.out.println(num);
        }
    }
}

Output:

Error: null
1
2
3
4
5

Using a loop: we can iterate over the array factors the usage of a loop and add them in my opinion to a collection.

ArrayToCollectionWithLoopExample.java

import java.util.ArrayList;
import java.util.List;
public class ArrayToCollectionWithLoopExample {
    public static void main(String[] args) {
        // Sample array of integers
        Integer[] intArray = {1, 2, 3, 4, 5};
        // Convert array to a List using a loop
        List<Integer> integerList = new ArrayList<>();
        for (Integer num : intArray) {
            integerList.add(num);
        }
        // Print the elements of the list
        for (Integer num : integerList) {
            System.out.println(num);
        }
    }
}

Output:

This approach offers us flexibility in appearing extra operations or adjustments on every detail before including it to the collection.

Using third-party libraries: There are several third-party libraries to be had, together with Guava and Eclipse Collections, that provide handy strategies for array-to-collection conversion. We can explore the documentation of those libraries for their unique conversion methods.

ArrayToCollectionWithGuavaExample.java

import com.google.common.collect.Lists;
import java.util.List;
public class ArrayToCollectionWithGuavaExample {
    public static void main(String[] args) {
        // Sample array of integers
        Integer[] intArray = {1, 2, 3, 4, 5};
        // Convert array to a List using Guava
        List<Integer> integerList = Lists.newArrayList(intArray);
        // Print the elements of the list
        for (Integer num : integerList) {
            System.out.println(num);
        }
    }
}

Output:

Using the Stream API with ArrayUtils from Apache Commons Library: If we had Apache Commons Lang library added on your undertaking, we can combine the Stream API with ArrayUtils.toObject() approach to transform an array to a set.

ArrayToCollectionExample.java

import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class ArrayToCollectionExample {
    public static void main(String[] args) {
        // Sample array of integers
        int[] intArray = {1, 2, 3, 4, 5};
        // Convert array to a List using the Stream API and ArrayUtils
        List<Integer> integerList = Arrays.stream(ArrayUtils.toObject(intArray)) .collect(Collectors.toList());
        // Print the elements of the list
        for (Integer num : integerList) {
            System.out.println(num);
        }
    }
}

Output:

Using the Stream API with the StreamSupport class: We can use the StreamSupport.Movement() technique along with an Iterable implementation to convert an array to a set.

ArrayToCollectionExample.java

import java.util.ArrayList;
import java.util.List;
import java.util.Spliterator;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class ArrayToCollectionExample {
    public static void main(String[] args) {
        // Sample array of integers
        int[] intArray = {1, 2, 3, 4, 5};
        // Convert array to a List using the Stream API and StreamSupport
        List<Integer> integerList = convertArrayToList(intArray);
        // Print the elements of the list
        for (Integer num : integerList) {
            System.out.println(num);
        }
    }
    private static List<Integer> convertArrayToList(int[] array) {
        // Create a Spliterator from the array
        Spliterator.OfInt spliterator = Spliterators.spliterator(array, Spliterator.ORDERED);
        // Create a stream from the Spliterator
        Stream<Integer> stream = StreamSupport.stream(spliterator, false);
        // Collect the stream elements into a List
        return stream.collect(Collectors.toList());
    }
}

Output:

The approach is beneficial when managing custom array kinds or when we had a custom Iterable implementation.

Using the LinkedList elegance: If we particularly need a LinkedList, we can convert the array with the aid of iterating over the elements and adding them to the list for my part.

ArrayToCollectionWithLinkedListExample.java

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class ArrayToCollectionWithLinkedListExample {
    public static void main(String[] args) {
        // Sample array of integers
        Integer[] intArray = {1, 2, 3, 4, 5};
        // Convert array to a LinkedList elegantly
        List<Integer> integerList = new LinkedList<>(Arrays.asList(intArray));
        // Print the elements of the list
        for (Integer num : integerList) {
            System.out.println(num);
        }
    }
}

Output:

Using the addAll() approach of a collection: If we had already got an empty collection, you could use the addAll() technique to feature the elements of the array to the collection.

ArrayToCollectionWithAddAllExample.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class ArrayToCollectionWithAddAllExample {
    public static void main(String[] args) {
        // Sample array of integers
        Integer[] intArray = {1, 2, 3, 4, 5};
        // Convert array to a List using the addAll() method
        List<Integer> integerList = new ArrayList<>();
        Collections.addAll(integerList, intArray);
        // Print the elements of the list
        for (Integer num : integerList) {
            System.out.println(num);
        }
    }
} 

Output:

These extra topics provide us more options for changing an array to a collection in Java. We can choose the technique that aligns along with our specific use case and takes benefit of the available Java versions and libraries.

In Summary, converting an array to a collection in Java can be accomplished using several different techniques. The Java Collections Framework provides various methods and interfaces to manage collections of objects efficiently.

The choice of method depends on the specific use case, desired collection type, and whether a mutable or unmodifiable collection is needed. It's important to understand the characteristics and behaviour of each method to make the right decision for the particular situation.

Next TopicJava Transaction API

← prev next →