如何在 Java 中返回数组？

2024年10月23日 | 阅读 10 分钟

在 Java 中，有几种方法可以从方法中返回数组，每种方法都有其自身的优点和用例。这些方法可大致分为静态数组、动态创建的数组、子数组以及使用 Java Streams 生成的数组。

首先，一种常见的方法是返回一个静态数组，它涉及在方法内直接定义数组元素并返回数组。此方法非常简单，适用于数组元素是预先知道的且保持不变的情况。例如，一个方法可以返回一个包含预定义值（如 {1, 2, 3, 4, 5}）的静态数组。

在本节中，我们将学习如何在 Java 中返回数组。

请记住

方法可以返回数组的引用。
方法的返回类型必须声明为正确数据类型的数组。

让我们通过一个 Java 示例程序来详细了解数组。

示例 1

文件名： ArrayDemo.java

import java.util.Arrays;
public class ArrayDemo {
    public static void main(String[] args) {
        // Declare an array
        int[] numbers;
        // Initialize the array with 5 elements
        numbers = new int[5];
        // Assign values to the array elements
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;
        // Print the array elements using a loop
        System.out.print("Array elements: ");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println();
        // Get the length of the array
        int length = numbers.length;
        System.out.println("Length of the array: " + length);
        // Create a copy of the array using Arrays.copyOf
        int[] copiedArray = Arrays.copyOf(numbers, numbers.length);
        // Print the copied array elements
        System.out.print("Copied array elements: ");
        for (int number : copiedArray) {
            System.out.print(number + " ");
        }
        System.out.println();
        // Compare the original array with the copied array
        boolean isEqual = Arrays.equals(numbers, copiedArray);
        System.out.println("Are arrays equal? " + isEqual);
        // Sort the array
        Arrays.sort(numbers);
        // Print the sorted array elements
        System.out.print("Sorted array elements: ");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println();
        // Fill the array with a specific value
        Arrays.fill(numbers, 100);
        // Print the filled array elements
        System.out.print("Filled array elements: ");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println();
        // Convert the array to a string using Arrays.toString
        String arrayAsString = Arrays.toString(numbers);
        System.out.println("Array as string: " + arrayAsString);
    }
}

输出

示例 2

在以下示例中，该方法返回一个 double 类型的数组。

public class ReturnArrayExample3
{
public static double[] returnArray( )
{
double[] arr = new double [3];    // Creating an array of 3 elements
arr[0]=6.9;
arr [1]=2.5;
arr [2]=11.5;
return( x );         	// Return the reference of the array
}
public static void main(String[] args)
{
double[] a;			//variable to store returned array
a = returnArray();		//called method
for (int i = 0; i < a.length; i++) //for loop to print the array
System.out.println( a[i]+ " ");   
}
}

示例 1

文件名： ReturnArrayExample1.java

import java.util.Arrays;  
public class ReturnArrayExample1  
{  
public static void main(String args[])  
{  
int[] a=numbers();           //obtain the array  
for (int i = 0; i < a.length; i++) //for loop to print the array  
System.out.print( a[i]+ " ");     
}  
public static int[] numbers()  
{  
int[] arr={5,6,7,8,9};  //initializing array  
return arr;  
}  
}  

输出

示例 2

文件名： ReturnArrayExample2.java

在以下示例中，该方法返回一个 double 类型的数组。

public class ReturnArrayExample2  
{  
public static double[] returnArray( )  
{  
double[] arr = new double [3];    // Creating an array of 3 elements  
arr[0]=6.9;  
arr [1]=2.5;  
arr [2]=11.5;  
return( x );            // Return the reference of the array  
}  
public static void main(String[] args)  
{  
double[] a;         //variable to store returned array  
a = returnArray();      //called method  
for (int i = 0; i < a.length; i++) //for loop to print the array  
System.out.println( a[i]+ " ");     
}  
}  

输出

示例 3

文件名： ReturnArrayExample3.java

在以下示例中，该方法返回一个对象类型的数组。

import java.util.Arrays;  
class ReturnArrayExample3  
{  
public static int[] returnArray()  
{  
int a1=20;  
int a2=23;  
int a3=87;  
return new int[] {a1,a2,a3};     //returns array  
}  
public static void main(String args[])  
{  
int[] arr=returnArray();    //invoking method and storing returned array into arr  
System.out.println(Arrays.toString(arr));   //returns the string representation of the object  
}  
}  

输出

在 Java 中返回数组

在 Java 中返回数组之前，有几个重要事项需要注意，让我们在接下来的段落中详细讨论它们。

返回数组的方法必须包含与要返回的数组完全相同的数据类型返回类型。方法和数组的返回类型可能因 Java 中可用的大范围数据类型而异，例如int、long、float、double、char、Boolean
必须精确准确地使用访问修饰符，同时牢记方法的利用和返回以及数组。在这种情况下，必须考虑 static 和 non-static 等声明。
当一个数组由一个方法返回到另一个方法时，必须有一个具有相同数据类型的相同类型的数组来接受由该方法返回的数据或数组。当接收数组与返回数组的数据类型不同时，会产生错误，程序不会执行。

实施

在 Java 中，返回数组涉及在方法中创建一个数组，然后将其返回给调用者。对于简单的内置数组（即原始数据类型的数组，如 int、double、char 等），方法可以生成并返回一个随机整数数组。此过程包括创建指定大小的整数数组，用随机值填充它，然后将其返回给调用者。例如，可以实现一个 `generateRandomIntArray(int size)` 方法来实现此目的。

在处理对象数组时（其中数组的每个元素都是某个类的对象），方法会创建一个对象数组，初始化这些对象，然后返回该数组。例如，可以使用 `getPeople()` 方法返回一个 `Person` 对象数组，其中每个 `Person` 对象都用姓名和年龄初始化。这演示了创建和返回对象数组的过程。

在涉及多维数组（即数组的数组）的情况下，方法会创建一个多维数组，用值填充它，然后返回它。例如，可以实现一个 `getMultiplicationTable(int size)` 方法来返回一个二维数组，该数组表示指定大小的乘法表。这包括用从 1 到指定大小的每对数字的乘法结果填充数组。

让我们来看看上述重要点的实现。

为了更好地理解这个主题，让我们通过三种不同的情况来看这个主题的实现。

1. 返回内置数组

在此场景或情况下，我们将返回一个数组，该数组将是 Java 中可用的基本数据类型，例如 int、float、char、Boolean、double、long、short 等。

文件名： ArrayReturn.java

import java.io.*;
class ArrayReturn {
    // 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++) {
            // Print each element of the array
            System.out.print(storage[i]);
            // Print a space after each element except the last one
            if (i < storage.length - 1) {
                System.out.print(" ");
            }
        }
        // Print a new line
        System.out.println();
    }
    // Method 2
    // Returning an integer array
    public static int[] methodReturningArray() {
        // Creating an integer array
        int[] sample = { 1, 2, 3, 4 };
        // Return statement of the method.
        return sample;
    }
}

输出

1 2 3 4

2. 返回对象数组

我们可以像返回默认数据类型数组一样返回对象数组。让我们看看上述点的实现。

文件名： ArrayReturn1.java

import java.io.*;
class Courses {
    String name;
    int modules;
    // Constructor to instantiate class objects.
    public Courses(String n, int m) {
        // This keyword refers to the 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++) {
            // Printing each object's name and modules
            System.out.print(sample[i].name + " - "
                             + sample[i].modules
                             + " modules\n");
        }
    }
    // Method 2
    // Note that the return type is an array of Courses objects
    public static Courses[] methodReturningArray() {
        // Declaring an 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

3. 返回多维数组

多维数组可以描述为存储在数组中的数组。多维数组的最佳示例是二维数组。多维数组的声明和大小基于它们的大小。让我们通过 Java 中的方法来实现如何返回多维数组（二维数组）。

文件名： ArrayReturn3.java

// Importing input output classes
import java.io.*;
// Main class
class ArrayReturn3.java {
    // Method 1
    // Main driver method
    public static void main(String[] args)
    {
        // Calling the methodReturningArray method
        int[][] storage = methodReturningArray();
        // Printing the returned array
        System.out.println("Printing the returned array:");
        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();
        }
        // Accessing and printing specific elements of the returned array
        System.out.println("\nAccessing specific elements:");
        System.out.println("Element at [0][0]: " + storage[0][0]);
        System.out.println("Element at [1][2]: " + storage[1][2]);
        System.out.println("Element at [2][1]: " + storage[2][1]);
        // Calculating and printing the sum of all elements in the array
        int sum = 0;
        for (int i = 0; i < storage.length; i++) {
            for (int j = 0; j < storage[0].length; j++) {
                sum += storage[i][j];
            }
        }
        System.out.println("\nSum of all elements: " + sum);
        // Creating and printing a new array based on the returned array
        System.out.println("\nCreating a new array based on the returned array:");
        int[][] newArray = new int[3][3];
        for (int i = 0; i < storage.length; i++) {
            for (int j = 0; j < storage[0].length; j++) {
                newArray[i][j] = storage[i][j] * 2;
                System.out.print(newArray[i][j] + " ");
            }
            System.out.println();
        }
        // Printing a message indicating the end of the program
        System.out.println("\nEnd of program.");
    }
    // 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, 10, 11, 12 } };
        // Return statement of the method
        return sample;
    }
}

输出

Printing the returned array:
1 2 3 4
5 6 7 8
9 10 11 12

Accessing specific elements:
Element at [0][0]: 1
Element at [1][2]: 7
Element at [2][1]: 10

Sum of all elements: 78

让我们通过一个 Java 示例程序来详细了解如何在 Java 中返回数组。

文件名：ReturnArrayExamples.java

import java.util.Arrays;
public class ReturnArrayExamples {
    // Method 1: Returning a static array
    public static int[] returnStaticArray() {
        // Create a static array {1, 2, 3, 4, 5} and return it
        int[] staticArray = {1, 2, 3, 4, 5};
        return staticArray;
    }
    // Method 2: Returning a dynamically created and populated array
    public static int[] returnDynamicArray(int size) {
        // Create an array of the specified size
        int[] dynamicArray = new int[size];
        // Populate the array with values from 1 to size
        for (int i = 0; i < size; i++) {
            dynamicArray[i] = i + 1;
        }
        // Return the dynamically created array
        return dynamicArray;
    }
    // Method 3: Using Arrays.copyOfRange to return a subarray
    public static int[] returnSubArray(int[] arr, int start, int end) {
        // Create a new array to hold the subarray
        int[] subArray = Arrays.copyOfRange(arr, start, end);
        // Return the subarray
        return subArray;
    }
    // Method 4: Using System.arraycopy to return a subarray
    public static int[] returnSubArrayUsingSystemArrayCopy(int[] arr, int start, int end) {
        // Calculate the length of the subarray
        int length = end - start;
        // Create a new array to hold the subarray
        int[] subArray = new int[length];
        // Copy elements from arr starting at index start to the new array subArray
        System.arraycopy(arr, start, subArray, 0, length);
        // Return the subarray
        return subArray;
    }
    // Method 5: Using Java Streams to return an array
    public static int[] returnArrayUsingStreams(int size) {
        // Use Java Streams to generate an array of size containing values from 1 to size
        int[] streamArray = java.util.stream.IntStream.rangeClosed(1, size).toArray();
        return streamArray;
    }
    public static void main(String[] args) {
        // Demonstrate each method by printing the returned array
        System.out.println("Static Array: " + Arrays.toString(returnStaticArray()));
        System.out.println("Dynamic Array: " + Arrays.toString(returnDynamicArray(5)));
        int[] originalArray = {1, 2, 3, 4, 5};
        System.out.println("Subarray using Arrays.copyOfRange: " + Arrays.toString(returnSubArray(originalArray, 1, 3)));
        System.out.println("Subarray using System.arraycopy: " + Arrays.toString(returnSubArrayUsingSystemArrayCopy(originalArray, 1, 3)));
        System.out.println("Array using Java Streams: " + Arrays.toString(returnArrayUsingStreams(5)));
    }
}

输出

Static Array: [1, 2, 3, 4, 5]
Dynamic Array: [1, 2, 3, 4, 5]
Subarray using Arrays.copyOfRange: [2, 3]
Subarray using System.arraycopy: [2, 3]
Array using Java Streams: [1, 2, 3, 4, 5]

下一个主题Java 教程

如何在 Java 中返回数组？

示例 1

示例 2

示例 1

示例 2

示例 3

在 Java 中返回数组

实施

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

如何在 Java 中返回数组？

示例 1

示例 2

示例 1

示例 2

示例 3

在 Java 中返回数组

实施

相关帖子

Java 中 ExecutorService 的 execute() 和 submit() 方法的区别

Java Web 开发

Java 中的倾斜二叉树

Java 8 中的终端操作

Java 中将 Set 转换为 List

Java 中检查两个给定矩阵是否互为镜像

Java 中静态函数的阴影

DoubleBuffer allocate() method in Java With Examples

Java UTF

Java 中的汉明码

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器