Java数组

通常情况下，数组是一组具有相同数据类型的元素的集合，这些元素在内存中是连续存储的。

Java 数组是包含相同数据类型元素的对象。数组的元素被存储在连续的内存位置上。它是用来存储相似元素的数据结构，且只能存储固定数量的元素。

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

与 C/C++ 不同，我们可以使用 length 属性来获取数组的长度，在 C/C++ 中需要使用 sizeof 运算符。

在 Java 中，数组是动态生成的类的对象。Java 数组继承了 Object 类，并实现了 Serializable 和 Cloneable 接口。我们可以在 Java 中将原始值或对象存储在数组中。与 C/C++ 类似，我们可以创建单维或多维数组。

另外，Java 还提供了匿名数组的特性，这是 C/C++ 所不具备的。

1.gif

优点

  • 代码优化： 数组使得代码更加优化，可以高效地检索和排序数据。
  • 随机访问： 我们可以通过索引直接访问数组中的任意元素。

缺点

  • 大小限制： 数组的大小是固定的，无法在运行时动态改变大小。为了解决这个问题，Java 提供了自动增长的集合框架。

Java 中的数组类型

在 Java 中有两种类型的数组：

  • 一维数组：包含单个维度的数组。
  • 多维数组：包含多个维度的数组。

Java 中的一维数组

在 Java 中声明数组的语法

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

Java中数组的实例化

arrayRefVar=new datatype[size];

Java数组的例子

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

//Java程序来说明如何声明、实例化、初始化 
//并遍历Java数组。 
class Testarray{  
public static void main(String args[]){  
int a[]=new int[5];//声明和实例化   
a[0]=10;//初始化  
a[1]=20;  
a[2]=70;  
a[3]=40;  
a[4]=50;  
//遍历数组  
for(int i=0;i<a.length;i++)//length是数组的属性
System.out.println(a[i]);  
}}

输出：

10
20
70
40
50

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

我们可以通过以下方式一起声明、实例化和初始化 java 数组：

int a[]={33,3,4,5};//声明、实例化和初始化

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

//Java程序说明声明、实例化的使用   
//并在一行中初始化 Java 数组   
class Testarray1{  
public static void main(String args[]){  
int a[]={33,3,4,5};//声明、实例化和初始化   
//打印数组   
for(int i=0;i<a.length;i++)//length是数组的属性  
System.out.println(a[i]);  
}}

输出：

33
3
4
5

Java 数组的 For-each 循环

我们还可以使用 for-each 循环来遍历和打印 Java 数组。Java 的 for-each 循环可以逐个访问数组元素。它将数组中的每个元素依次赋值给一个变量，并执行循环体内的操作。通过这种方式，我们可以方便地遍历数组并打印其中的元素。

for-each 循环的语法如下：

for(data_type variable:array){  
//循环体 
}

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

//Java 程序使用 for-each 循环打印数组元素  
class Testarray1{  
public static void main(String args[]){  
int arr[]={33,3,4,5};  
//使用for-each循环打印数组   
for(int i:arr)  
System.out.println(i);  
}}

输出：

33
3
4
5

将数组传递给 Java 中的方法

我们可以将 java 数组传递给方法，以便我们可以在任何数组上重用相同的逻辑。

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

//Java程序演示传递数组的方式  
//方法.  
class Testarray2{  
//创建一个接收数组作为参数的方法   
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};//声明并初始化一个数组   
min(a);//传递数组给方法 
}}

输出：

3

Java 中的匿名数组

Java 支持匿名数组的特性，因此在将数组传递给方法时无需声明数组。

//Java程序演示传递匿名数组的方式  
//方法.  
public class TestAnonymousArray{  
//创建一个接收数组作为参数的方法  
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});//传递匿名数组给方法
}}

输出：

10
22
44
66

从方法返回数组

我们还可以从 Java 中的方法返回一个数组。

//Java程序从方法返回一个数组   
class TestReturnArray{  
//创建返回数组的方法  
static int[] get(){  
return new int[]{10,30,50,90,60};  
}  
  
public static void main(String args[]){  
//调用返回数组的方法   
int arr[]=get();  
//打印数组的值  
for(int i=0;i<arr.length;i++)  
System.out.println(arr[i]);  
}}

输出：

10
30
50
90
60

ArrayIndexOutOfBoundsException异常

如果在遍历数组时数组的长度为负、等于数组大小或大于数组大小，则 Java 虚拟机 (JVM) 将抛出 ArrayIndexOutOfBoundsException。

//Java程序来演示的情况    
//Java 数组中的 ArrayIndexOutOfBoundsException.  
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 中声明多维数组的语法

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

Java实例化多维数组的例子

int[][] arr=new int[3][3];//3 row and 3 column

Java初始化多维数组的例子

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

多维 Java 数组示例

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

//Java程序说明多维数组的使用   
class Testarray3{  
public static void main(String args[]){  
//声明和初始化二维数组  
int arr[][]={{1,2,3},{2,4,5},{4,4,5}};  
//打印二维数组  
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
2 4 5
4 4 5

Java 中的锯齿状数组

如果我们在二维数组中创建奇数列，则称为锯齿状数组。换句话说，它是具有不同列数的数组的数组。

//Java程序来说明锯齿状数组   
class TestJaggedArray{  
    public static void main(String[] args){  
        //声明一个奇数列的二维数组   
        int arr[][] = new int[3][];  
        arr[0] = new int[3];  
        arr[1] = new int[4];  
        arr[2] = new int[2];  
        //初始化一个锯齿状数组  
        int count = 0;  
        for (int i=0; i<arr.length; i++)  
            for(int j=0; j<arr[i].length; j++)  
                arr[i][j] = count++;  
   
        //打印锯齿状数组的数据     
        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();//新队   
        }  
    }  
}

输出：

0 1 2 
3 4 5 6 
7 8

Java数组的类名是什么？

在 Java 中，数组是一个对象。对于数组对象，会创建一个代理类，其名称可以通过对象的 getClass().getName() 方法获取。

//Java程序获取Java中数组的类名 
class Testarray4{  
public static void main(String args[]){  
//数组的声明和初始化  
int arr[]={4,4,5};  
//获取Java数组的类名  
Class c=arr.getClass();  
String name=c.getName();  
//打印Java数组的类名   
System.out.println(name);  
  
}}

输出：

I

复制 Java 数组

我们可以通过 System 类的 arraycopy() 方法将一个数组复制到另一个数组。

arraycopy 方法的语法

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

在 Java 中复制数组的示例

//Java 将源数组复制到 Java 中的目标数组的 Java 程序 
class TestArrayCopyDemo {  
    public static void main(String[] args) {  
        //声明一个源数组 
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',  
                'i', 'n', 'a', 't', 'e', 'd' };  
        //声明一个目标数组   
        char[] copyTo = new char[7];  
        //使用System.arraycopy()方法复制数组 
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);  
        //打印目标数组  
        System.out.println(String.valueOf(copyTo));  
    }  
}

输出：

caffein

在 Java 中克隆一个数组

由于 Java 数组实现了 Cloneable 接口，我们可以创建 Java 数组的克隆。当我们克隆一维数组时，它会创建该数组的深拷贝，也就是复制实际的值。然而，当我们克隆多维数组时，它会创建该数组的浅拷贝，也就是复制引用。这意味着多维数组的克隆将共享内部数组的引用，而不是复制内部数组本身。所以在多维数组的克隆中，修改一个数组会影响到其他数组的对应位置。

//克隆数组的Java程序   
class Testarray1{  
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 中添加 2 个矩阵

让我们看一个添加两个矩阵的简单示例。

//Java程序演示Java中两个矩阵的加法   
class Testarray5{  
public static void main(String args[]){  
//创建两个矩阵   
int a[][]={{1,3,4},{3,4,5}};  
int b[][]={{1,3,4},{3,4,5}};  
  
//创建另一个矩阵来存储两个矩阵的和  
int c[][]=new int[2][3];  
  
//添加和打印2个矩阵的加法   
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();//新队 
}  
  
}}

输出：

2 6 8
6 8 10

Java 中 2 个矩阵的乘法

在矩阵乘法的情况下，第一个矩阵的单行元素乘以第二个矩阵的所有列，这可以通过下图理解。

2.png

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

//两个矩阵相乘的Java程序  
public class MatrixMultiplicationExample{  
public static void main(String args[]){  
//创建两个矩阵   
int a[][]={{1,1,1},{2,2,2},{3,3,3}};    
int b[][]={{1,1,1},{2,2,2},{3,3,3}};    
    
//创建另一个矩阵来存储两个矩阵的乘积     
int c[][]=new int[3][3];  //3 rows and 3 columns  
    
//乘法和打印2个矩阵的乘法    
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];      
}//k循环结束
System.out.print(c[i][j]+" ");  //printing matrix element  
}//j循环结束  
System.out.println();//new line    
}    
}}

输出：

6 6 6 
12 12 12 
18 18 18

标签: java, Java面试题, Java下载, java教程, java技术, Java学习, Java学习教程, Java语言, Java开发, Java入门教程, Java进阶教程, Java高级教程, Java笔试题, Java编程思想