How To Return An Array In Java? A Detailed Guide With Examples

13 mins read

When working with arrays in Java, we often need to pass them around in our code. But what if we need to return an array from a method? Understanding how to do this is essential for writing clean and efficient Java programs. In this article, we’ll explore how to return an array in Java, with easy-to-follow examples that will help you understand the concept step by step. Let’s get started!

Why Return An Array In Java?

Returning an array in Java programming is useful when a method needs to provide multiple values as a result. Instead of returning separate values, we can package them into an array and return them as a single entity.

Advantages Of Returning An Array:

1. Multiple Results: We can return a collection of related data as a single unit. Example: Returning all even numbers from a given range.
2. Ease of Iteration: Once returned, the array can be easily traversed using loops or enhanced for-loops.
3. Compact Code: Eliminates the need for multiple return statements or separate variables for each value.

Explore this amazing course and master all the key concepts of Java programming effortlessly!

How To Return An Array In Java

Returning an array from a method in Java is a straightforward process. It involves defining a method with an array as the return type, populating the array within the method, and using the return statement to send the array back to the caller. 

Syntax: 

returnType[] methodName(parameters) {
    // Step 1: Create an array
    returnType[] arrayName = new returnType[size];   
    // Step 2: Populate the array (optional)
    // Example: arrayName[index] = value;   
    // Step 3: Return the array
    return arrayName;
}

The steps to return an array in Java are as follows:

1. Declare the Method with an Array Return Type: Specify the data type of the array in the method signature, followed by square brackets ([]). Example: int[], String[], double[], etc.
2. Create and Populate the Array: Inside the method, create an array using the new keyword. Populate the array with data either manually or using a loop.
3. Use the return Statement: Use the return keyword to send the array back to the calling code.
4. Access the Returned Array: The calling method receives the returned array, which can be stored in a variable and accessed using loops or array indexing.

Example 1: Returning An Array Of First N Squares

Let’s create a method that returns an array containing the squares of the first n natural numbers.

Code Example: 

public class ArrayReturnExample {

    // Step 1: Declare a method with an array return type
    public static int[] generateSquares(int n) {
        // Step 2: Create and populate the array
        int[] squares = new int[n]; // Create an array of size n
        for (int i = 0; i < n; i++) {
            squares[i] = (i + 1) * (i + 1); // Store square of (i+1)
        }
        // Step 3: Return the array
        return squares;
    }

    public static void main(String[] args) {
        // Step 4: Access the returned array
        int n = 5; // Define the size
        int[] result = generateSquares(n); // Call the method and get the array

        // Print the returned array
        System.out.println("First " + n + " square numbers:");
        for (int num : result) {
            System.out.print(num + " "); // Output: 1 4 9 16 25
        }
    }
}

Output (set code file name as ArrayReturnExample.java): 

1 4 9 16 25

Explanation: 

In the above code example-

1. We start by defining a method generateSquares() that returns an array of integers. This method is tasked with generating the square numbers for the first n positive integers.
2. Inside the method, we create an integer array squares of size n. This array will hold the square numbers.
3. We use a for loop to populate the array. For each index i, the value stored is the square of (i + 1) to ensure the sequence starts from 1 rather than 0.
4. Once the array is filled with the desired square numbers, we return it using the return statement.
5. In the main() method, we define the size n as 5 and call the generateSquares() method to obtain the array of squares.
6. The returned array is stored in the variable result, which we then use to print the square numbers.
7. To display the numbers, we use an enhanced for loop that iterates through each element in the array, printing the values in a single line separated by spaces.
8. The final output for n = 5 is: 1 4 9 16 25, which represents the squares of the first five positive integers.

Sharpen your coding skills with Unstop's 100-Day Coding Sprint and compete now for a top spot on the leaderboard!

Example 2: Doubling the Values of an Array

In this example, we will create a method that takes an array of integers as input, doubles each value, and then returns the new array with the doubled values.

Code Example: 

public class ArrayReturnExample {

    // Method that takes an array, doubles the values, and returns the new array
    public static int[] doubleValues(int[] numbers) {
        int[] doubledNumbers = new int[numbers.length]; // Create a new array of the same length

        for (int i = 0; i < numbers.length; i++) {
            doubledNumbers[i] = numbers[i] * 2; // Double each value
        }

        return doubledNumbers; // Return the new array
    }

    public static void main(String[] args) {
        // Create an array of integers
        int[] originalArray = {1, 2, 3, 4, 5};

        // Call the method to double the values in the array
        int[] doubledArray = doubleValues(originalArray);

        // Print the original and the doubled arrays
        System.out.print("Original Array: ");
        for (int num : originalArray) {
            System.out.print(num + " ");
        }
        System.out.println();

        System.out.print("Doubled Array: ");
        for (int num : doubledArray) {
            System.out.print(num + " ");
        }
    }
}

Output (set code file name as ArrayReturnExample.java): 

Original Array: 1 2 3 4 5
Doubled Array: 2 4 6 8 10

Explanation:

In the above code example-

1. We begin by defining a method doubleValues() that takes an array of integers numbers as input, doubles each value, and returns a new array containing the doubled values.
2. Inside the method, we create a new array doubledNumbers with the same length as the input array numbers. This array will store the doubled values.
3. We then use a for loop to iterate through each element of the numbers array. For each element, we multiply it by 2 and store the result in the corresponding position in the doubledNumbers array.
4. After the loop finishes, the doubledNumbers array, which contains the doubled values, is returned.
5. In the main() method, we define an array originalArray with the values {1, 2, 3, 4, 5}.
6. We call the doubleValues() method, passing originalArray as an argument, and store the result in doubledArray.
7. To display the arrays, we use two separate for loops to print both the original array and the doubled array. Each number is printed with a space between them.
8. The final output shows the original array followed by the doubled values.

Common Scenarios For Returning Arrays In Java

When working with Java, returning arrays from methods is useful in many real-world scenarios. Here are some common use cases:

1. Processing Input Data

• Scenario: A method processes input data (like user-provided numbers) and returns the results as an array.
• Example: A method takes an array of integers, doubles each value, and returns the new array.

public static int[] doubleValues(int[] numbers) {
    int[] doubled = new int[numbers.length];
    for (int i = 0; i < numbers.length; i++) {
        doubled[i] = numbers[i] * 2;
    }
    return doubled;
}

• Use Case: Useful for data transformation or applying operations to a collection of inputs.

2. Splitting Data

• Scenario: A method splits a single data source into multiple parts and returns the segments as an array.
• Example: Splitting a sentence into words and returning the words in a string array.

public static String[] splitSentence(String sentence) {
    return sentence.split(" ");
}

• Use Case: Common in text processing, log analysis, and parsing CSV data.

3. Generating Sequential or Computed Data

• Scenario: A method generates an array based on a specific rule or computation.
• Example: Generating an array of the first n square numbers.

public static int[] generateSquares(int n) {
    int[] squares = new int[n];
    for (int i = 0; i < n; i++) {
        squares[i] = i * i;
    }
    return squares;
}

• Use Case: Often used in mathematical or simulation-based programs.

4. Returning Filtered Data

• Scenario: A method filters an input array and returns only the elements that meet a specific condition.
• Example: Filtering even numbers from an input array.

public static int[] filterEvenNumbers(int[] numbers) {
    return Arrays.stream(numbers)
                 .filter(num -> num % 2 == 0)
                .toArray();
}

• Use Case: Common in scenarios where selective data extraction is needed.

5. Returning Multidimensional Arrays

• Scenario: A method creates and returns a 2D array, often for tabular or grid-based data.
• Example:
  Creating a multiplication table and returning it as a 2D array.

public static int[][] generateMultiplicationTable(int size) {
    int[][] table = new int[size][size];
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            table[i][j] = (i + 1) * (j + 1);
        }
    }
    return table;
}

• Use Case: Useful for matrix operations, game grids, or visualizing data.

6. Combining Data

• Scenario: A method combines multiple arrays or datasets into a single array and returns it.
• Example: Merging two integer arrays.

public static int[] mergeArrays(int[] arr1, int[] arr2) {
    int[] merged = new int[arr1.length + arr2.length];
    System.arraycopy(arr1, 0, merged, 0, arr1.length);
    System.arraycopy(arr2, 0, merged, arr1.length, arr2.length);
    return merged;
}

• Use Case: Useful in applications where data consolidation is required.

7. Returning Default or Empty Arrays

• Scenario: A method might return an empty array if there’s no data to process.
• Example: Returning an empty array when input is invalid.

public static int[] getEmptyArrayIfNull(int[] input) {
    if (input == null) {
        return new int[0]; // Return empty array
    }
    return input;
}

• Use Case: Helps avoid null references and ensures predictable results.

Points To Remember When Returning Arrays In Java

When returning arrays in Java, it’s crucial to ensure proper initialization, handle edge cases like empty arrays, and be mindful of their mutable nature to maintain code reliability and efficiency. Here are some of the important points:

1. Arrays Are Objects: Arrays in Java are treated as objects, meaning they are passed and returned by reference, not by value.
2. Define the Correct Return Type: The return type of the method must match the type of the array being returned (e.g., int[], String[], etc.).
3. Memory Allocation: Arrays must be initialized using new or a literal before returning; otherwise, you’ll encounter a NullPointerException when trying to access the array.
4. Mutable Nature of Arrays: Changes made to the returned array in the calling code will affect the original array, as only the reference is passed.
5. Avoid Returning Null: If there’s a possibility that no meaningful array can be returned, ensure you handle it in the calling code to prevent runtime errors.
6. Return Empty Arrays Instead of Null: It’s a good practice to return an empty array (new int[0]) rather than null to avoid NullPointerException.
7. Fixed Size: The size of the array is fixed once it is created. If a dynamic size is required, consider using collections like ArrayList.
8. Access and Iterate Properly: Use loops (for, for-each) or array indexing to access elements of the returned array in the calling code.
9. Encapsulation Best Practices: If the array should not be modified by the caller, return a copy of the array instead of the original to maintain encapsulation.
10. Multidimensional Arrays: The same principles apply when returning multidimensional arrays (e.g., int[][]), but ensure proper initialization and handling.

Are you looking for someone to answer all your programming-related queries? Let's find the perfect mentor here.

Conclusion

Returning arrays in Java is a powerful technique that allows us to handle and manipulate collections of data efficiently. By understanding how arrays work and how to return them from methods, we can create flexible and reusable code for various use cases, such as processing data, generating results, or filtering information.

As we’ve seen through examples, returning arrays is straightforward, but it’s important to remember that arrays are returned by reference, which means changes to the returned array can affect the original data. Keeping best practices in mind, such as cloning arrays when needed and handling edge cases like empty arrays, ensures robust and error-free programs.

With practice, this concept becomes an indispensable tool in your Java programming arsenal. Try implementing the scenarios we discussed, and see how arrays can simplify your coding tasks!

Frequently Asked Questions

Q. Can a method return an empty array in Java?

Yes, a method can return an empty array in Java. This is often used in situations where no data is available or when you want to indicate that a collection is empty. You can return an empty array by initializing it with a size of 0, like so:

return new int[0];

This ensures that the method will return a valid array object, preventing potential NullPointerExceptions.

Q. How is returning an array different from returning other objects?

Arrays in Java are objects, so when you return an array, you’re returning a reference to the array, not the actual array itself. This means that if you modify the returned array, the changes will affect the original array in the calling code. This behavior is the same for all objects in Java, but arrays are often more prone to issues because they are usually accessed in larger sizes or multiple locations.

If you want to avoid this reference-sharing behavior, you can return a copy (using array.clone() or Arrays.copyOf()), which creates a new array with the same elements but independent of the original.

Q. Can a method return a multidimensional array?

Yes, a method can return a multidimensional array, such as a 2D or 3D array. A multidimensional array is essentially an array of arrays. For example, a method can return a 2D array representing a matrix of integers:

public static int[][] generateMatrix(int rows, int cols) {
    int[][] matrix = new int[rows][cols];
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * j;
        }
    }
    return matrix;
}

This allows you to handle more complex data structures, such as grids or tables, and return them from a method.

Q. What happens if I return null instead of an array?

If a method returns null instead of an array, it means the method didn’t create or find any data to return. This can lead to a NullPointerException if the calling code tries to access or manipulate the returned value without checking for null. It is safer to return an empty array (new int[0]) rather than null to avoid this potential error and maintain consistency in your code.

Q. Can arrays of different data types be returned from a single method?

No, a method can only return arrays of a single data type. However, if you need to return different types, you can use an Object[] array to store elements of various types. Keep in mind that when using Object[], you lose type safety and will need to cast the elements to their appropriate types when you retrieve them, which can lead to ClassCastException if not handled correctly. For Example:

public static Object[] returnMultipleTypes() {
    return new Object[] { 1, "Hello", true };
}

Q. Are changes to a returned array reflected in the original array?

Yes, since arrays are passed by reference in Java, any changes made to the returned array will also reflect in the original array. This is because the returned array points to the same memory location as the original one.

To prevent this, you can return a copy of the array instead of the original array using array.clone() or Arrays.copyOf():

public static int[] getArrayCopy(int[] original) {
    return original.clone(); // Returns a new array, leaving the original unchanged
}

This ensures that modifications to the returned array will not affect the original array.

With this, we can conclude our discussion on how to return an array in Java. Here are a few other topics that you might be interested in reading: 

1. Convert String To Date In Java | 3 Different Ways With Examples
2. Final, Finally & Finalize In Java | 15+ Differences With Examples
3. Super Keyword In Java | Definition, Applications & More (+Examples)
4. How To Find LCM Of Two Numbers In Java? Simplified With Examples
5. How To Find GCD Of Two Numbers In Java? All Methods With Examples
6. Volatile Keyword In Java | Syntax, Working, Uses & More (+Examples)
7. This Keyword In Java | Syntax, Best Practices & More (+Examples)