Convert Integer List to Int Array

Introduction

This lab will guide you through the process of converting an Integer List to an int Array in Java. This is a common task in Java programming when you need to work with primitive arrays after collecting data in a List.

We will explore two different approaches to accomplish this conversion:

1. Using Java's Stream API with the stream.mapToInt() method
2. Using Apache Commons Lang's ArrayUtils.toPrimitive() method

By the end of this lab, you will understand both methods and be able to apply them in your own Java applications.

Skills Graph

Create a Java Class for Our Experiment

In this first step, we'll create a Java class to demonstrate the conversion methods. We'll use Maven to manage our dependencies and project structure.

1. First, verify that you're in the project directory:

cd /home/labex/project

2. Create a new Java file in the Maven source directory:

cd src/main/java

3. Create IntegerListToIntArray.java with the following content:

import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.ArrayUtils;

public class IntegerListToIntArray {
    public static void main(String[] args) {
        System.out.println("Converting Integer List to int Array Demo");
        System.out.println("---------------------------------------");

        // We'll add our code here in the following steps
    }
}

4. Compile the code using Maven:

cd /home/labex/project
mvn compile

5. Run the program to verify it works:

mvn exec:java

You should see the header text printed to the console. If there are no errors, you're ready to move to the next step.

Create and Populate an Integer List

In this step, we'll create an Integer List and add some numbers to it. Before we start coding, let's understand why we need this conversion.

Why Convert Between Integer List and int Array?

In Java, we have two ways to work with numbers:

1. Primitive Type (int):

   • Basic number type that stores just the number
   • Uses less memory
   • Cannot be used directly in collections like List
   • Example: int x = 5;

2. Wrapper Class (Integer):

   • Object that contains a number
   • Can be used in collections like List
   • Has additional methods and features
   • Example: Integer x = 5;

We often collect numbers in a List (which requires Integer), but some methods need a primitive int array for better performance. This is why we need to convert between them.

Update the Java Code

Let's modify our IntegerListToIntArray.java file to create and display a list of numbers:

1. Make sure you're in the project directory:

cd /home/labex/project

2. Open src/main/java/IntegerListToIntArray.java and add the following code inside the main method, after the existing print statements:

// Create a List of Integer objects
List<Integer> integerList = new ArrayList<>();

// Add some numbers to the list
integerList.add(1);
integerList.add(2);
integerList.add(3);
integerList.add(4);
integerList.add(5);

// Display the list contents
System.out.println("Original Integer List:");
for (Integer num : integerList) {
    System.out.print(num + " ");
}
System.out.println("\n");

3. Compile and run the program:

mvn compile
mvn exec:java

You should see output similar to this:

Converting Integer List to int Array Demo
---------------------------------------
Original Integer List:
1 2 3 4 5

This output confirms that we have successfully created an Integer List and populated it with numbers. In the next step, we'll learn how to convert this list to a primitive int array.

Convert List to Array Using Stream API

In this step, we'll learn our first method to convert an Integer List to an int array using Java's Stream API. The Stream API provides a modern and efficient way to process collections of data.

Understanding Java Streams

A Stream in Java is like a pipeline that can process data step by step:

• It takes data from a source (our List)
• Processes the data (converts Integer to int)
• Collects the results (into an array)

Add the Conversion Code

1. Make sure you're in the project directory:

cd /home/labex/project

2. Open src/main/java/IntegerListToIntArray.java and add this code after your list creation code:

// Method 1: Using Stream API
System.out.println("Converting using Stream API:");

// Convert Integer List to int array using Stream
int[] intArrayUsingStream = integerList.stream()    // Create a stream from the list
                                     .mapToInt(Integer::intValue)  // Convert Integer to int
                                     .toArray();    // Collect results into an array

// Print the converted array
System.out.println("Converted int Array:");
for (int value : intArrayUsingStream) {
    System.out.print(value + " ");
}
System.out.println("\n");

3. Compile and run the program:

mvn compile
mvn exec:java

You should see output like this:

Converting Integer List to int Array Demo
---------------------------------------
Original Integer List:
1 2 3 4 5

Converting using Stream API:
Converted int Array:
1 2 3 4 5

Understanding the Code

Let's break down how the conversion works:

1. integerList.stream() - Creates a stream from our list
2. .mapToInt(Integer::intValue) - Converts each Integer to an int
3. .toArray() - Collects all the int values into an array

The Integer::intValue is called a method reference. It's a shorthand way of writing number -> number.intValue().

Convert List to Array Using ArrayUtils

In this step, we'll learn a second method to convert our list using the Apache Commons Lang library's ArrayUtils class. This method is more straightforward and might be easier to understand for beginners.

Understanding ArrayUtils

The ArrayUtils class provides many helpful methods for working with arrays. The toPrimitive() method specifically helps us convert from wrapper types (like Integer) to primitive types (like int).

Add the ArrayUtils Conversion Code

1. Add this code to your IntegerListToIntArray.java file after the Stream API code:

// Method 2: Using ArrayUtils
System.out.println("Converting using ArrayUtils:");

// First convert List<Integer> to Integer[]
Integer[] intermediateArray = integerList.toArray(new Integer[0]);

// Then convert Integer[] to int[]
int[] intArrayUsingArrayUtils = ArrayUtils.toPrimitive(intermediateArray);

// Print the converted array
System.out.println("Converted int Array:");
for (int value : intArrayUsingArrayUtils) {
    System.out.print(value + " ");
}
System.out.println("\n");

2. Compile and run the program:

mvn compile
mvn exec:java

You should now see both conversion methods in the output:

Converting Integer List to int Array Demo
---------------------------------------
Original Integer List:
1 2 3 4 5

Converting using Stream API:
Converted int Array:
1 2 3 4 5

Converting using ArrayUtils:
Converted int Array:
1 2 3 4 5

Understanding the Code

The ArrayUtils method works in two steps:

1. integerList.toArray(new Integer[0]) - Converts the List to an array of Integer objects
2. ArrayUtils.toPrimitive() - Converts the Integer array to an int array

This method is more straightforward but requires the Apache Commons Lang library.

Summary

In this lab, you learned two different ways to convert an Integer List to an int Array in Java:

1. Using Java's Stream API:

int[] array = integerList.stream().mapToInt(Integer::intValue).toArray();

• Modern and functional approach
• Built into Java
• Good for processing data in steps

2. Using Apache Commons Lang's ArrayUtils:

int[] array = ArrayUtils.toPrimitive(integerList.toArray(new Integer[0]));

• More straightforward approach
• Requires external library
• Easy to understand and use

Both methods achieve the same result, and you can choose the one that better fits your needs:

• Use Stream API when you want a modern, functional approach
• Use ArrayUtils when you want simpler, more readable code

You now have the knowledge to convert between Integer Lists and int arrays in your Java applications.