¿Cómo devolver una array en Java?

Una array es una estructura de datos que consta de un grupo de elementos del mismo tipo de datos, de modo que cada elemento de la array puede identificarse mediante un único índice o clave de array. Los elementos de la array se almacenan de manera que la dirección de cualquiera de los elementos se puede calcular utilizando la ubicación del primer índice de la array utilizando una relación matemática simple. Las arrays en Java son diferentes en implementación y uso en comparación con las de C/C++, aunque también tienen muchas similitudes. Aquí discutiremos cómo devolver una array en Java.

Para devolver una array en Java, debemos tener en cuenta los siguientes puntos:

Punto clave 1: el método que devuelve la array debe tener el tipo de devolución como una array del mismo tipo de datos que la array que se devuelve. El tipo de retorno puede ser también los objetos de clase Integer, Double, Character, String o definidos por el usuario habituales.

// Method returning an integer array.
int[] methodName() {...}

// Method returning a String array.
String[] methodName() {...}

// Method returning an array of objects of class named Students.
Students[] methodName() {...} 

Punto clave 2: los modificadores de acceso deben usarse con precisión teniendo en cuenta el uso del método y la array de retorno. También se deben tener en cuenta las declaraciones estáticas y no estáticas.

// Using public access modifier and static to call the method from a static class, method or block.
public static char[] methodName() {...} 

Punto clave 3: debe haber cualquier array variable del mismo tipo de datos o algo similar en la llamada al método para manejar la array que se devuelve. Por ejemplo, una array de enteros devuelta por cualquier método se puede almacenar de la siguiente manera.

int[] storage = methodReturningArray();

Implementación:

Para comprender mejor esto, podemos analizar algunos tipos diferentes de escenarios en los que podemos devolver arrays. Aquí consideraremos tres ejemplos de escenarios.

• Caso 1: arreglos integrados simples
• Caso 2: Array de objetos
• Caso 3: devolución de arreglos multidimensionales

Caso 1: devolver una array de enteros (tipo de datos integrado) en Java

Cualquier array de tipo de datos incorporado, ya sea entero, carácter, flotante, doble, todo puede devolverse simplemente usa declaraciones de retorno teniendo en cuenta los puntos enumerados anteriormente. 

Ejemplo

// Java Program to Illustrate Returning
// simple built-in arrays
 
// Importing input output classes
import java.io.*;
 
// Main class
class GFG {
 
    // Method 1
    // Main driver method
    public static void main(String[] args)
    {
        // An integer array storing the returned array
        // from the method
        int[] storage = methodReturningArray();
 
        // Printing the elements of the array
        for (int i = 0; i < storage.length; i++)
            System.out.print(storage[i] + " ");
    }
 
    // Method 2
    // Returning an integer array
    public static int[] methodReturningArray()
    {
        int[] sample = { 1, 2, 3, 4 };
 
        // Return statement of the method.
        return sample;
    }
}

1 2 3 4 

Caso 2: Devolver una array de objetos en Java

Esto se hace exactamente de manera similar en el caso de devolver arrays de tipos de datos integrados.

Ejemplo 

// Java Program to Illustrate Returning
// an array of objects in java
 
// Importing all input output classes
import java.io.*;
 
// Class 1
// Helper class
// Courses whose objects are returned as an array
class Courses {
 
    String name;
    int modules;
 
    // Constructor to instantiate class objects.
    public Courses(String n, int m)
    {
        // This keyword refers to current instance  itself
        this.name = n;
        this.modules = m;
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Method 1
    // Main driver method
    public static void main(String[] args)
    {
        // Calling the method for returning an array of
        // objects of the Courses class.
        Courses[] sample = methodReturningArray();
 
        // Printing the returned array elements.
        for (int i = 0; i < sample.length; i++)
            System.out.print(sample[i].name + " - "
                             + sample[i].modules
                             + " modules\n");
    }
 
    // Method 2
    // Note that return type is an array
    public static Courses[] methodReturningArray()
    {
        // Declaring Array of objects of the Courses class
        Courses[] arr = new Courses[4];
 
        // Custom array of objects
        arr[0] = new Courses("Java", 31);
        arr[1] = new Courses("C++", 26);
        arr[2] = new Courses("DSA", 24);
        arr[3] = new Courses("DBMS", 12);
 
        // Statement to return an array of objects
        return arr;
    }
}

Java - 31 modules
C++ - 26 modules
DSA - 24 modules
DBMS - 12 modules

Caso 3: devolución de arreglos multidimensionales 

Se puede decir que las arrays multidimensionales en Java son una array de arrays dentro de arrays. La forma más simple puede ser una array bidimensional. Tienen sus talles y declaración de acuerdo a sus talles. Aquí se demuestra a continuación la devolución de una array bidimensional que tiene un enfoque muy similar a las arrays unidimensionales.

Ejemplo 

// Java Program to Illustrate Returning
// Multi-dimensional Arrays
 
// Importing input output classes
import java.io.*;
 
// Main class
class GFG {
 
    // Method 1
    // Main driver method
    public static void main(String[] args)
    {
        // An integer 2D array storing the
        // returned array from the method
        int[][] storage = methodReturningArray();
 
        // Printing the elements of the array
        // using nested for loops
        for (int i = 0; i < storage.length; i++) {
            for (int j = 0; j < storage[0].length; j++)
 
                System.out.print(storage[i][j] + " ");
 
            System.out.println();
        }
    }
 
    // Method 2
    // Returning an integer array
    public static int[][] methodReturningArray()
    {
        // Custom 2D integer array
        int[][] sample
            = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
 
        // Return statement of the method
        return sample;
    }
}

1 2 3 
4 5 6 
7 8 9