Java 数组

2025年4月28日 | 阅读 16 分钟

数组通常是相同类型的元素的集合，它们存储在单个连续的内存块中。

Java 数组是一个对象，包含相同数据类型的元素。此外，数组的元素存储在连续的内存位置。它是一种存储相似元素的结构。Java 数组只能存储固定数量的元素。

Java 中的数组是基于索引的，数组的第一个元素存储在索引 0 处，第二个元素存储在索引 1 处，依此类推。

与 C/C++ 不同，Java 使用 length 成员来获取数组的长度。而在 C/C++ 中，我们必须使用 sizeof 运算符。

Java 中的数组是动态创建的类的对象。Java 数组实现了 Serializable 和 Cloneable 接口，并继承自 Object 类。在 Java 中，数组可以包含对象或原始值。与 C/C++ 一样，Java 允许我们创建一维或多维数组。

此外，C/C++ 不支持 Java 提供的匿名数组功能。

优点

代码优化：它可以优化代码，我们可以高效地检索或排序数据。
随机访问：我们可以获取位于任何索引位置的数据。

缺点

大小限制：数组的大小是固定的，在运行时不会动态增长。

Java 数组的类型

数组有两种类型。

一维数组
多维数组

Java 中的一维数组

Java 中的一维数组是相同数据类型元素的线性集合。它使用以下语法声明和实例化

dataType[] arr; (or)
dataType []arr; (or)
dataType arr[];

Java 数组的实例化

Java 数组示例

让我们看一个简单的 Java 数组示例，我们将声明、实例化、初始化和遍历一个数组。

示例

//Java Program to illustrate how to declare, instantiate, initialize  
//and traverse the Java array.  
public class Main{  
 public static void main(String args[]){  
    //declaration and instantiation of an array
    int a[]=new int[5];
    a[0]=10;//initialization  
    a[1]=20;  
    a[2]=70;  
    a[3]=40;  
    a[4]=50;  
    //traversing array  
    for(int i=0;i<a.length;i++){//length is the property of array  
        System.out.println(a[i]);  
    }
 }
}  

编译并运行

输出

Java 数组的声明、实例化和初始化

在 Java 中，您可以在一行中声明、实例化和初始化一个数组，如下所示：

让我们看一个打印此数组的简单示例。

示例

//Java Program to illustrate the use of declaration, instantiation   
//and initialization of Java array in a single line  
public class Main{  
 public static void main(String args[]){  
    //declaration, instantiation and initialization of an array
    int a[]={33,3,4,5};
    //traversing array  
    for(int i=0;i<a.length;i++)//length is the property of array  
        System.out.println(a[i]);  
 }
}  

编译并运行

输出

Java 数组的 for-each 循环

我们也可以使用for-each 循环打印 Java 数组。Java for-each 循环一次打印一个数组元素。它将一个数组元素保存在一个变量中，然后执行循环体。

for-each 循环的语法如下：

for(data_type variable:array){
//body of the loop
}

让我们看一个使用 for-each 循环打印 Java 数组元素的示例。

示例

//Java Program to print the array elements using for-each loop  
public class Main{  
 public static void main(String args[]){  
    //declaration and initialization of an array
    int arr[]={33,3,4,5};  
    //traversal of an array using for-each loop  
    for(int i:arr)  
        System.out.println(i);  
 }
}  

编译并运行

输出

将数组传递给 Java 方法

我们可以将 Java 数组传递给方法，以便我们可以对任何数组重用相同的逻辑。当我们把一个数组传递给 Java 方法时，我们实际上是传递数组的引用。这意味着该方法将能够访问与调用代码相同的数组数据，并且在方法内对数组所做的任何修改都将影响原始数组。

让我们看一个使用方法获取数组最小值的简单示例。

示例

//Java Program to demonstrate the way of passing an array to method.  
public class Main{  
//creating a method which receives an array as a parameter  
    static void min(int arr[]){  
        int min=arr[0];  
        for(int i=1;i<arr.length;i++)  
            if(min>arr[i])  
                min=arr[i];  
  
        System.out.println(min);  
    }  
  
 public static void main(String args[]){  
    int a[]={33,3,4,5};//declaring and initializing an array  
    min(a);//passing array to method  
 }
}  

编译并运行

输出

说明

此 Java 程序演示了将数组传递给方法的概念。min 方法以整数数组 arr 作为参数，并使用简单的迭代循环查找数组中的最小值。在 main 方法中，声明并初始化了一个整数数组 a，其值为 {33, 3, 4, 5}，然后将此数组作为参数调用 min 方法。min 方法遍历数组以查找最小值并将其打印到控制台。

Java 中的匿名数组

Java 的匿名数组通过允许开发人员在方法调用或其他表达式中直接创建和初始化数组，消除了单独声明数组变量的需要。这在处理仅用于一次性任务且不需要在程序中进行持久引用的临时数组时非常有用。

Java 支持匿名数组功能，因此我们在将数组传递给方法时无需声明该数组。

示例

//Java Program to demonstrate the way of passing an anonymous array to method  
public class Main{  
    //creating a method which receives an array as a parameter  
    static void printArray(int arr[]){  
        for(int i=0;i<arr.length;i++)  
            System.out.println(arr[i]);  
    }  
 public static void main(String args[]){  
    printArray(new int[]{10,22,44,66});//passing anonymous array to method  
 }
}  

编译并运行

输出

说明

在此示例中，printArray 方法以整数数组作为参数，并打印数组的每个元素。在 main 方法中，将匿名数组 {10, 20, 30} 直接作为参数传递给 printArray 方法。这种简洁的语法演示了 Java 中匿名数组的用法，允许更精简的代码，而无需中间变量声明。

从方法返回数组

在 Java 中，方法不仅可以返回简单数据类型或对象，还可以返回数组。此功能允许方法设计更加灵活，并使开发人员能够将生成数组的复杂逻辑封装在方法中。

示例

//Java Program to return an array from the method  
public class Main{  
    //creating method which returns an array  
    static int[] get(){  
        return new int[]{10,30,50,90,60};  
    }  
 public static void main(String args[]){  
    //calling method which returns an array  
    int arr[]=get();  
    //printing the values of an array  
    for(int i=0;i<arr.length;i++)  
        System.out.println(arr[i]);  
 }
}

编译并运行

输出

说明

该示例演示了如何在 Java 中从方法返回数组，并随后在调用代码中使用返回的数组。通过将数组创建和初始化逻辑封装在 get 方法中，代码变得更加模块化和可重用。

ArrayIndexOutOfBoundsException

在 Java 中，ArrayIndexOutOfBoundsException 是 Java 虚拟机 (JVM) 在尝试访问数组的无效索引时抛出的运行时异常。如果索引为负数、等于数组大小，或者在遍历数组时大于数组大小，则会发生此异常。

TestArrayException.java

//Java Program to demonstrate the case of 
//ArrayIndexOutOfBoundsException in a Java Array.
public class TestArrayException{
public static void main(String args[]){
int arr[]={50,60,70,80};
for(int i=0;i<=arr.length;i++){
System.out.println(arr[i]);
}
}}

输出

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
	at TestArrayException.main(TestArrayException.java:5)
50
60
70
80

Java 中的多维数组

Java 中的多维数组是数组的数组，其中每个元素本身都可以是一个数组。它有助于以行和列格式存储数据。

Java 中声明多维数组的语法

dataType[][] arrayRefVar; (or)
dataType [][]arrayRefVar; (or)
dataType arrayRefVar[][]; (or)
dataType []arrayRefVar[]; 

Java 中实例化多维数组的示例

Java 中初始化多维数组的示例

arr[0][0]=1;
arr[0][1]=2;
arr[0][2]=3;
arr[1][0]=4;
arr[1][1]=5;
arr[1][2]=6;
arr[2][0]=7;
arr[2][1]=8;
arr[2][2]=9;

多维 Java 数组示例

让我们看一个声明、实例化、初始化和打印二维数组的简单示例。

示例

public class Main {  
    public static void main(String args[]) {  
        int arr[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 3x3 matrix  
        // Printing the 2D array  
        for (int i = 0; i < 3; i++) {  
            for (int j = 0; j < 3; j++) {  
                System.out.print(arr[i][j] + " ");  
            }  
            System.out.println();  
        }  
    }  
}  

编译并运行

输出

1 2 3
4 5 6
7 8 9

说明

此 Java 程序初始化并打印一个二维数组，该数组表示一个 3x3 矩阵。最初，一个名为 arr 的二维数组使用数组初始化器语法声明并用值初始化。该数组包含三行，每行包含三个列。然后，程序使用嵌套循环遍历数组的每一行和每一列。在循环中，它打印每个元素的值，之间用空格分隔。打印完一行的所有元素后，会打印一个换行符以移至下一行。此过程一直持续到打印完数组的所有元素。结果，程序输出 3x3 矩阵，每个元素显示在其各自的行和列中。

这些示例演示了 Java 中一维和多维数组的声明、实例化、初始化和遍历。

Java 中的锯齿数组

在 Java 中，锯齿数组是数组的数组，其中数组的每一行可以具有不同数量的列。这与常规二维数组不同，后者的每一行都具有相同数量的列。

声明和初始化锯齿数组

要在 Java 中声明锯齿数组，您首先声明数组的数组，然后分别使用其自己的列数组初始化每一行。

int arr[][] = new int[3][];  
arr[0] = new int[3];  
arr[1] = new int[4];  
arr[2] = new int[2];

示例

//Java Program to illustrate the jagged array  
public class Main{  
    public static void main(String[] args){  
        //declaring a 2D array with odd columns  
        int arr[][] = new int[3][];  
        arr[0] = new int[3];  
        arr[1] = new int[4];  
        arr[2] = new int[2];  
        //initializing a jagged array  
        int count = 0;  
        for (int i=0; i<arr.length; i++)  
            for(int j=0; j<arr[i].length; j++)  
                arr[i][j] = count++;  
   
        //printing the data of a jagged array   
        for (int i=0; i<arr.length; i++){  
            for (int j=0; j<arr[i].length; j++){  
                System.out.print(arr[i][j]+" ");  
            }  
            System.out.println();//new line  
        }  
    }  
}  

编译并运行

输出

0 1 2 
3 4 5 6 
7 8

说明

此 Java 程序演示了锯齿数组的概念，其中创建了一个数组的数组，每个内部数组具有不同数量的列：第一行有 3 列，第二行有 4 列，第三行有 2 列。然后，程序通过用从 0 开始的连续值填充锯齿数组来初始化它。最后，它遍历数组并逐行打印每个元素，之间用空格分隔，每行末尾有一个换行符。

Java 数组的类名是什么？

在 Java 中，数组是一个对象。然而，Java 中的数组有一个特殊功能，即 JVM 为每个数组对象生成一个代理类。此代理类表示数组的运行时类型。要获取 Java 数组的类名，可以使用所有 Java 对象都可用的 getClass().getName() 方法。此方法返回一个表示对象类名的字符串，包括任何包信息。

示例

//Java Program to get the class name of array in Java  
public class Main{  
 public static void main(String args[]){  
    //declaration and initialization of array  
    int arr[]={4,4,5};  
    //getting the class name of Java array  
    Class c=arr.getClass();  
    String name=c.getName();  
    //printing the class name of Java array   
    System.out.println(name);  
 }
}  

编译并运行

输出

[I

说明

此 Java 程序演示了如何使用 getClass().getName() 方法检索 Java 数组的类名。它使用整数值初始化数组 arr，使用 getClass() 获取数组的运行时类，并使用 getName() 检索类名。获得的类名（通常表示为单个字符后跟方括号）反映了数组的维度和元素类型。

复制 Java 数组

在 Java 中，可以使用 System 类的 arraycopy() 方法复制数组。此方法允许您将元素从源数组复制到目标数组，并指定起始位置和长度。

arraycopy 方法的语法

public static void arraycopy(
Object src, int srcPos,Object dest, int destPos, int length
)

其中，src 是源数组，srcPos 是源数组的起始位置，dest 是目标数组，destPos 是目标数组的起始位置，length 是要复制的元素数量。

示例

//Java Program to copy a source array into a destination array in Java  
public class Main {  
    public static void main(String[] args) {  
        //declaring a source array  
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',  
                'i', 'n', 'a', 't', 'e', 'd' };  
        //declaring a destination array  
        char[] copyTo = new char[7];  
        //copying array using System.arraycopy() method  
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);  
        //printing the destination array  
        System.out.println(String.valueOf(copyTo));  
    }  
}  

编译并运行

输出

caffein

说明

Java 程序初始化了两个字符数组 copyFrom 和 copyTo，并预定义了值。然后，它使用 System.arraycopy() 方法将 copyFrom 数组的一部分复制到 copyTo 数组中，从索引 2 开始，复制 7 个元素。最后，它打印 copyTo 数组的内容，输出为 "caffein"。

克隆 Java 数组

在 Java 中，数组实现了 Cloneable 接口，允许我们创建数组的克隆。如果我们创建一维数组的克隆，它会创建 Java 数组的深拷贝。这意味着它将复制实际值。但是，如果我们创建多维数组的克隆，它会创建 Java 数组的浅拷贝，这意味着它复制的是引用。

这种区别很重要，因为修改浅拷贝多维数组中的元素会影响原始数组和克隆数组，而在深拷贝一维数组中，修改不会影响原始数组。

TestarrayClone.java

//Java Program to clone the array  
class TestarrayClone{  
public static void main(String args[]){  
int arr[]={33,3,4,5};  
System.out.println("Printing original array:");  
for(int i:arr)  
System.out.println(i);  
System.out.println("Printing clone of the array:");  
int carr[]=arr.clone();  
for(int i:carr)  
System.out.println(i);  
System.out.println("Are both equal?");  
System.out.println(arr==carr);  
}
}  

输出

Printing original array:
33
3
4
5
Printing clone of the array:
33
3
4
5
Are both equal?
False

说明

在这个 Java 程序中，一个名为 arr 的整数数组用数字 {33, 3, 4, 5} 初始化，并打印其元素。然后，它使用 clone() 方法克隆 arr，将结果赋给 carr，并打印克隆数组的元素。该程序的最后一行使用 == 运算符比较 arr 和 carr；结果评估为 false，表示 arr 和 carr 是不同的数组对象。然而，两个数组中的元素是相同的。

Java 中两个矩阵相加

矩阵加法是线性代数和计算机科学中的基本运算，常用于科学计算、计算机图形学和图像处理等各种应用。在 Java 中相加两个矩阵时，需要创建一个与原始矩阵具有相同维度的矩阵，并将每个矩阵中对应的元素相加。此 Java 程序通过使用堆叠循环进行一个基本过程示例，演示了如何有效地相加矩阵。

让我们看一个简单的例子，将两个矩阵相加。

ArrayAddition.java

//Java Program to demonstrate the addition of two matrices in Java
class ArrayAddition{
public static void main(String args[]){
//creating two matrices
int a[][]={{1,3,4},{3,4,5}};
int b[][]={{1,3,4},{3,4,5}};

//creating another matrix to store the sum of two matrices
int c[][]=new int[2][3];

//adding and printing addition of 2 matrices
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
c[i][j]=a[i][j]+b[i][j];
System.out.print(c[i][j]+" ");
}
System.out.println();//new line
}

}}

输出

2 6 8
6 8 10

说明

此 Java 程序通过逐个元素地相加两个预定义的矩阵 a 和 b，并将结果存储在矩阵 c 中来演示矩阵加法。矩阵 a 和 b 用值初始化，并创建矩阵 c 来存储总和。它使用嵌套循环遍历矩阵的每个元素，将 a 和 b 中对应的元素相加，并将结果存储在 c 中对应的位置。最后，它打印结果矩阵 c。输出显示了两个矩阵的逐元素相加，结果矩阵 c 中的每个元素都是 a 和 b 中相应元素之和。

Java 中两个矩阵相乘

矩阵乘法是数学和计算机科学中的一项关键运算，通常用于图形渲染、优化算法和科学计算等各种应用。在 Java 中，将两个矩阵相乘涉及一个系统化的过程，其中结果矩阵中的每个元素都是通过将第一个矩阵的行与第二个矩阵的列进行点积来计算的。

让我们看一个将 3 行 3 列的两个矩阵相乘的简单示例。

MatrixMultiplicationExample.java

//Java Program to multiply two matrices
public class MatrixMultiplicationExample{
public static void main(String args[]){
//creating two matrices  
int a[][]={{1,1,1},{2,2,2},{3,3,3}};  
int b[][]={{1,1,1},{2,2,2},{3,3,3}};  
  
//creating another matrix to store the multiplication of two matrices  
int c[][]=new int[3][3];  //3 rows and 3 columns
  
//multiplying and printing multiplication of 2 matrices  
for(int i=0;i<3;i++){  
for(int j=0;j<3;j++){  
c[i][j]=0;    
for(int k=0;k<3;k++)    
{    
c[i][j]+=a[i][k]*b[k][j];    
}//end of k loop
System.out.print(c[i][j]+" ");  //printing matrix element
}//end of j loop
System.out.println();//new line  
}  
}}

输出

6 6 6 
12 12 12 
18 18 18

说明

此 Java 程序计算两个 3x3 矩阵“a”和“b”的乘积，并将结果存储在矩阵“c”中。它用预定义的值初始化矩阵“a”和“b”，并创建矩阵“c”来存储结果。使用嵌套循环，它遍历结果矩阵“c”的每个元素，计算矩阵“a”和“b”中相应行和列元素的点积。计算出的每个元素的结果累积在“c”的相应位置。

结论

总而言之，数组是 Java 中至关重要的数据结构，它们提供了一种实用方法来存储和管理元素集合。Java 数组具有许多优点，包括支持一维和多维结构、快速随机访问以及有效的数据检索。Java 数组通过支持将数组发送到方法以及通过各种循环结构进行轻松遍历和操作，进一步促进了代码的可重用性和模块化设计。

此外，Java 还提供了其他功能，可以提高 Java 编程中数组的功能性和适应性，包括匿名数组、数组克隆以及矩阵加法和乘法等矩阵运算。但是，重要的是要理解存在限制，如固定大小和可能的运行时异常（如 ArrayIndexOutOfBoundsException）。

Java 数组选择题

1. 关于 Java 数组，以下哪个说法是正确的？

Java 数组的大小可以动态改变。
Java 数组可以存储不同数据类型的元素。
Java 数组总是用默认值初始化。
Java 数组不允许重复元素。

答案：c)

解释：在 Java 中，数组会用默认值初始化（例如，数值类型为 0，引用类型为 null，布尔类型为 false）。Java 数组一旦创建，大小就是固定的，只能存储一种类型的数据，并且允许重复元素。

2. Java 数组实现了以下哪个接口？

列表
Cloneable
Serializable
B 和 C 均支持

答案：d)

解释：Java 数组实现了 Cloneable 和 Serializable 接口，允许数组被克隆和序列化。

3. 什么是 Java 中的匿名数组？

一种未指定类型的数组。
一种未经命名的数组，用于一次性使用。
一种大小可以动态改变的数组。
一种在未指定大小的情况下声明的数组。

答案：b)

解释：匿名数组是没有引用名称的数组，它在方法调用中直接创建和使用。例如，new int[]{1, 2, 3}。

4. 如果我们尝试访问一个大于或等于数组长度的索引处的元素，会发生什么？

程序将因段错误而崩溃。
程序将返回一个默认值。
程序将抛出 ArrayIndexOutOfBoundsException。
程序将编译但无法运行。

答案：c)

解释：使用超出边界的索引访问数组将抛出 ArrayIndexOutOfBoundsException。

5. 在 Java 中，哪个方法用于将元素从一个数组复制到另一个数组？

System.clone()
System.arraycopy()
Arrays.copy()
Collections.copy()

答案：b)

解释：System.arraycopy() 方法用于将元素从一个数组复制到另一个数组。语法是 System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)。

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 教程

控制语句

Java Object 类

Java 继承

Java 多态

Java 抽象

Java 封装

Java 数组

Java OOPs 杂项

Java 字符串

Java 正则表达式

异常处理

Java 内部类

Java 多线程

Java 同步

Java I/O

Java 文件处理

Java 序列化

Java 网络

Java 反射

Java 集合

Java 5 特性

Java 8 特性

Java JDBC

RMI

国际化

Java 项目

Java 数组

优点

缺点

Java 数组的类型

Java 中的一维数组

Java 数组示例

示例

Java 数组的声明、实例化和初始化

示例

Java 数组的 for-each 循环

示例

将数组传递给 Java 方法

示例

Java 中的匿名数组

示例

从方法返回数组

示例

ArrayIndexOutOfBoundsException

Java 中的多维数组

多维 Java 数组示例

示例

Java 中的锯齿数组

声明和初始化锯齿数组

示例

Java 数组的类名是什么？

示例

复制 Java 数组

示例

克隆 Java 数组

Java 中两个矩阵相加

Java 中两个矩阵相乘

结论

Java 数组选择题