Wie gibt man ein Array in Java zurück?
Ein Array ist eine Datenstruktur, die aus einer Gruppe von Elementen desselben Datentyps besteht, sodass jedes Element des Arrays durch einen einzelnen Array-Index oder -Schlüssel identifiziert werden kann. Die Elemente des Arrays werden so gespeichert, dass die Adresse eines beliebigen Elements unter Verwendung der Position des ersten Index des Arrays unter Verwendung einer einfachen mathematischen Beziehung berechnet werden kann. Arrays in Java unterscheiden sich in Implementierung und Verwendung im Vergleich zu denen in C/C++, obwohl sie auch viele Ähnlichkeiten aufweisen. Hier werden wir besprechen, wie man ein Array in Java zurückgibt.
Um ein Array in Java zurückzugeben, müssen wir uns um die folgenden Punkte kümmern:
Schlüsselpunkt 1: Die Methode, die das Array zurückgibt, muss als Rückgabetyp ein Array des gleichen Datentyps wie das zurückgegebene Array haben. Der Rückgabetyp kann auch die üblichen Integer-, Double-, Character-, String- oder benutzerdefinierten Klassenobjekte sein.
// Method returning an String array.
int[] methodName() {...}
// Method returning a String array.
String[] methodName() {...}
// Method returning an array of objects of class named Students.
Students[] methodName() {...}
Schlüsselpunkt 2: Zugriffsmodifikatoren müssen unter Berücksichtigung der Verwendung der Methode und des zurückgegebenen Arrays genau verwendet werden. Auch statische und nichtstatische Deklarationen müssen berücksichtigt werden.
// Using public access modifier and static to call the method from a static class, method or block.
public static char[] methodName() {...}
Schlüsselpunkt 3: Beim Methodenaufruf muss ein beliebiges Variablenarray desselben Datentyps oder etwas Ähnliches vorhanden sein, um das zurückgegebene Array zu verarbeiten. Beispielsweise kann ein Integer-Array, das von einer beliebigen Methode zurückgegeben wird, wie folgt gespeichert werden.
int[] storage = methodReturningArray();
Implementierung:
Um dies besser zu verstehen, können wir uns einige verschiedene Arten von Szenarien ansehen, in denen wir möglicherweise Arrays zurückgeben. Hier betrachten wir drei Beispiele für Szenarien.
- Fall 1: Einfache eingebaute Arrays
- Fall 2: Array von Objekten
- Fall 3:
Fall 1: Rückgabe eines Integer-Arrays (eingebauter Datentyp) in Java
Jedes Array eines eingebauten Datentyps, sei es integer, character, float, double all kann zurückgegeben werden, indem einfach return-Anweisungen verwendet werden, wobei die oben aufgeführten Punkte zu beachten sind.
Beispiel
Java
// 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
Fall 2: Zurückgeben eines Arrays von Objekten in Java
Bei der Rückgabe von Arrays eingebauter Datentypen geschieht dies auf genau ähnliche Weise.
Beispiel
Java
// 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 instatiate 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 Module C++ - 26 Module DSA - 24 Module DBMS - 12 Module
Fall 3: Rückgabe mehrdimensionaler Arrays
Mehrdimensionale Arrays in Java können als Array von Arrays innerhalb von Arrays bezeichnet werden. Die einfachste Form kann ein zweidimensionales Array sein. Sie haben ihre Größen und Deklarationen entsprechend ihren Größen. Hier wird unten die Rückgabe eines zweidimensionalen Arrays demonstriert, das einen sehr ähnlichen Ansatz wie die eindimensionalen Arrays hat.
Beispiel
Java
// 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