Java中的数组

Java中的数组是一组由通用名称引用的类似类型的变量。 Java中的数组的工作方式与 C/C++ 中的不同。以下是有关Java数组的一些要点。

• 在Java中，所有数组都是动态分配的。 （下文讨论）
• 由于数组是Java中的对象，我们可以使用对象属性length找到它们的长度。这与 C/C++ 不同，在 C/C++ 中我们使用 sizeof 找到长度。
• Java数组变量也可以像其他变量一样在数据类型后面加上 [] 来声明。
• 数组中的变量是有序的，每个都有一个从 0 开始的索引。
• Java数组也可以用作静态字段、局部变量或方法参数。
• 数组的大小必须由 int 或 short 值指定，而不是 long。
• 数组类型的直接超类是 Object。
• 每个数组类型都实现了接口 Cloneable 和Java.io.Serializable。

根据数组的定义，数组可以包含类的基元（int、char 等）和对象（或非基元）引用。在原始数据类型的情况下，实际值存储在连续的内存位置。在类对象的情况下，实际对象存储在堆段中。

创建、初始化和访问数组

一维数组：

一维数组声明的一般形式是

type var-name[];
OR
type[] var-name;

数组声明有两个组成部分：类型和名称。 type声明数组的元素类型。元素类型确定组成数组的每个元素的数据类型。与整数数组一样，我们也可以创建其他原始数据类型的数组，如 char、float、double 等，或用户定义的数据类型（类的对象）。因此，数组的元素类型决定了数组将保存的数据类型。

例子：

// both are valid declarations
int intArray[]; 
or int[] intArray; 

byte byteArray[];
short shortsArray[];
boolean booleanArray[];
long longArray[];
float floatArray[];
double doubleArray[];
char charArray[];

// an array of references to objects of
// the class MyClass (a class created by
// user)
MyClass myClassArray[]; 

Object[]  ao,        // array of Object
Collection[] ca;  // array of Collection
                     // of unknown type

尽管第一个声明确定 intArray 是一个数组变量，但实际上并不存在数组。它只是告诉编译器这个变量（intArray）将保存一个整数类型的数组。要将 intArray 与实际的物理整数数组链接，您必须使用new分配一个并将其分配给 intArray。

在Java中实例化一个数组

声明数组时，只会创建数组的引用。要为数组创建或分配内存，您可以像这样创建一个数组： new应用于一维数组的一般形式如下所示：

var-name = new type [size];

这里， type指定要分配的数据类型， size确定数组中元素的数量， var-name是链接到数组的数组变量的名称。要使用new分配数组，您必须指定要分配的元素的类型和数量。

例子：

int intArray[];    //declaring array
intArray = new int[20];  // allocating memory to array

或者

int[] intArray = new int[20]; // combining both statements in one

笔记 ：

1. new分配的数组中的元素将自动初始化为零（对于数字类型）、 false （对于布尔值）或null （对于引用类型）。参考Java中的默认数组值
2. 获取数组是一个两步过程。首先，您必须声明所需数组类型的变量。其次，您必须使用 new 分配内存来保存数组，并将其分配给数组变量。因此，在Java中，所有数组都是动态分配的。

数组字面量

在数组大小和数组变量已知的情况下，可以使用数组字面量。

int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; 
 // Declaring array literal

• 这个数组的长度决定了创建的数组的长度。
• 无需在最新版本的Java中编写新的 int[] 部分。

使用 for 循环访问Java数组元素

数组中的每个元素都通过其索引访问。索引从 0 开始，到 (总数组大小)-1 结束。可以使用Java for Loop 访问数组的所有元素。

// accessing the elements of the specified array
for (int i = 0; i < arr.length; i++)
  System.out.println("Element at index " + i + 
                                " : "+ arr[i]);

执行：

Java

// Java program to illustrate creating an array
// of integers,  puts some values in the array,
// and prints each value to standard output.
 
class GFG
{
    public static void main (String[] args)
    {        
      // declares an Array of integers.
      int[] arr;
         
      // allocating memory for 5 integers.
      arr = new int[5];
         
      // initialize the first elements of the array
      arr[0] = 10;
         
      // initialize the second elements of the array
      arr[1] = 20;
         
      //so on...
      arr[2] = 30;
      arr[3] = 40;
      arr[4] = 50;
         
      // accessing the elements of the specified array
      for (int i = 0; i < arr.length; i++)
         System.out.println("Element at index " + i +
                                      " : "+ arr[i]);         
    }
}

输出

Element at index 0 : 10
Element at index 1 : 20
Element at index 2 : 30
Element at index 3 : 40
Element at index 4 : 50

时间复杂度： O(n)

辅助空间： O(1)

您还可以使用 foreach 循环访问Java数组。

对象数组

对象数组像原始类型数据项数组一样通过以下方式创建。

Student[] arr = new Student[7]; //student is a user-defined class

studentArray 包含七个内存空间，每个内存空间大小为学生类，其中可以存储七个学生对象的地址。 Student 对象必须使用 Student 类的构造函数进行实例化，并且它们的引用应按以下方式分配给数组元素。

Student[] arr = new Student[5];

Java

// Java program to illustrate creating
//  an array of objects
 
class Student
{
    public int roll_no;
    public String name;
    Student(int roll_no, String name)
    {
        this.roll_no = roll_no;
        this.name = name;
    }
}
 
// Elements of the array are objects of a class Student.
public class GFG
{
    public static void main (String[] args)
    {
        // declares an Array of integers.
        Student[] arr;
 
        // allocating memory for 5 objects of type Student.
        arr = new Student[5];
 
        // initialize the first elements of the array
        arr[0] = new Student(1,"aman");
 
        // initialize the second elements of the array
        arr[1] = new Student(2,"vaibhav");
 
        // so on...
        arr[2] = new Student(3,"shikar");
        arr[3] = new Student(4,"dharmesh");
        arr[4] = new Student(5,"mohit");
 
        // accessing the elements of the specified array
        for (int i = 0; i < arr.length; i++)
            System.out.println("Element at " + i + " : " +
                        arr[i].roll_no +" "+ arr[i].name);
    }
}

输出

Element at 0 : 1 aman
Element at 1 : 2 vaibhav
Element at 2 : 3 shikar
Element at 3 : 4 dharmesh
Element at 4 : 5 mohit

时间复杂度： O(n)

辅助空间： O(1)

如果我们尝试访问数组大小之外的元素会发生什么？

JVM 抛出ArrayIndexOutOfBoundsException表示该数组已被非法索引访问。索引为负数或大于或等于数组的大小。

Java

public class GFG
{
    public static void main (String[] args)
    {
        int[] arr = new int[2];
        arr[0] = 10;
        arr[1] = 20;
 
        for (int i = 0; i <= arr.length; i++)
            System.out.println(arr[i]);
    }
}

运行时错误

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at GFG.main(File.java:12)

输出

10
20

多维数组

多维数组是数组的数组，数组的每个元素都持有其他数组的引用。这些也称为锯齿状阵列。通过在每个维度附加一组方括号 ([]) 来创建多维数组。例子：

int[][] intArray = new int[10][20]; //a 2D array or matrix
int[][][] intArray = new int[10][20][10]; //a 3D array

Java

public class multiDimensional
{
    public static void main(String args[])
    {
        // declaring and initializing 2D array
        int arr[][] = { {2,7,9},{3,6,1},{7,4,2} };
 
        // printing 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();
        }
    }
}

输出

2 7 9 
3 6 1 
7 4 2 

将数组传递给方法

像变量一样，我们也可以将数组传递给方法。例如，下面的程序将数组传递给方法sum以计算数组值的总和。

Java

// Java program to demonstrate
// passing of array to method
 
public class Test
{   
    // Driver method
    public static void main(String args[])
    {
        int arr[] = {3, 1, 2, 5, 4};
         
        // passing array to method m1
        sum(arr);
     
    }
 
    public static void sum(int[] arr)
    {
        // getting sum of array values
        int sum = 0;
         
        for (int i = 0; i < arr.length; i++)
            sum+=arr[i];
         
        System.out.println("sum of array values : " + sum);
    }
}

输出

sum of array values : 15

时间复杂度： O(n)

辅助空间： O(1)

从方法返回数组

像往常一样，方法也可以返回一个数组。例如，下面的程序从方法m1返回一个数组。

Java

// Java program to demonstrate
// return of array from method
 
class Test
{   
    // Driver method
    public static void main(String args[])
    {
        int arr[] = m1();
         
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i]+" ");
     
    }
 
    public static int[] m1()
    {
        // returning  array
        return new int[]{1,2,3};
    }
}

输出

1 2 3 

时间复杂度： O(n)

辅助空间： O(1)

数组的类对象

每个数组都有一个关联的 Class 对象，与具有相同组件类型的所有其他数组共享。

Java

// Java program to demonstrate
// Class Objects for Arrays
 
class Test
{
    public static void main(String args[])
    {
        int intArray[] = new int[3];
        byte byteArray[] = new byte[3];
        short shortsArray[] = new short[3];
         
        // array of Strings
        String[] strArray = new String[3];
         
        System.out.println(intArray.getClass());
        System.out.println(intArray.getClass().getSuperclass());
        System.out.println(byteArray.getClass());
        System.out.println(shortsArray.getClass());
        System.out.println(strArray.getClass());
    }
}

输出

class [I
class java.lang.Object
class [B
class [S
class [Ljava.lang.String;

解释：

1. 字符串“[I”是类对象“具有组件类型int的数组”的运行时类型签名。
2. 数组类型的唯一直接超类是Java.lang.Object。
3. 字符串“[B”是类对象“具有组件类型字节的数组”的运行时类型签名。
4. 字符串“[S”是类对象“array with component type short ”的运行时类型签名。
5. 字符串“[L”是类对象“具有类的组件类型的数组”的运行时类型签名。然后是类名。

数组成员

现在，如您所知，数组是类的对象，而数组的直接超类是 Object 类。数组类型的成员全部如下：

• 公共最终字段长度，其中包含数组的组件数。长度可以是正数或零。
• 继承自类Object的所有成员； Object 唯一不被继承的方法是它的 clone 方法。
• 公共方法clone() ，它覆盖了类 Object 中的 clone 方法并且不抛出任何检查异常。

数组类型及其允许的元素类型

Array Types	Allowed Element Types
Primitive Type Arrays	Any type which can be implicitly promoted to declared type.
Object Type Arrays	Either declared type objects or it’s child class objects.
Abstract Class Type Arrays	Its child-class objects are allowed.
Interface Type Arrays	Its implementation class objects are allowed.

阵列的克隆

当您克隆一维数组（例如 Object[]）时，将使用包含原始数组元素副本而不是引用的新数组执行“深拷贝”。

Java

// Java program to demonstrate
// cloning of one-dimensional arrays
 
class Test
{   
    public static void main(String args[])
    {
        int intArray[] = {1,2,3};
         
        int cloneArray[] = intArray.clone();
         
        // will print false as deep copy is created
        // for one-dimensional array
        System.out.println(intArray == cloneArray);
         
        for (int i = 0; i < cloneArray.length; i++) {
            System.out.print(cloneArray[i]+" ");
        }
    }
}

输出

false
1 2 3 

然而，多维数组的克隆（如 Object[][]）是一个“浅拷贝”，也就是说，它只创建一个新数组，每个元素数组都是对原始元素数组的引用，但是子数组是共享的。

Java

// Java program to demonstrate
// cloning of multi-dimensional arrays
 
class Test
{   
    public static void main(String args[])
    {
        int intArray[][] = {{1,2,3},{4,5}};
         
        int cloneArray[][] = intArray.clone();
         
        // will print false
        System.out.println(intArray == cloneArray);
         
        // will print true as shallow copy is created
        // i.e. sub-arrays are shared
        System.out.println(intArray[0] == cloneArray[0]);
        System.out.println(intArray[1] == cloneArray[1]);
         
    }
}

输出

false
true
true

相关文章：

• Java中的锯齿状数组
• Java中的for-each循环
• Java中的数组类