Java中的数组arrays

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

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

根据数组的定义，数组可以包含基本数据类型以及类的对象。在基元数据类型的情况下，实际值存储在连续的存储位置。对于类的对象，实际对象存储在堆段中。

创建，初始化和访问数组

一维数组：

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

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

数组声明包含两个组件：类型和名称。类型声明数组的元素类型。元素类型决定了构成数组的每个元素的数据类型。类似于int类型的数组，我们也可以创建其他基本数据类型的数组，如char，float，double..etc或用户定义的数据类型（类的对象）。因此，数组的元素类型决定了数组将保存的数据。
例：

//都是有效的声明
int intArray []; 
或int [] intArray; 

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

//对象的引用数组
//类MyClass（一个类创建的
//用户）
MyClass myClassArray []; 

Object [] ao，// Object的数组
Collection[] ca; // Collection的数组
                     //未知类型

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

在Java中实例化一个数组

当我们声明一个数组时，只会创建一个数组的引用。为了实际创建或给出数组的内存，可以像下面这样创建一个数组：新的一般形式适用于一维数组，如下所示：

var-name = new type [size];

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

例：

int intArray []; //声明数组
intArray = new int [20]; //将内存分配给数组

要么

int [] intArray = new int [20]; //将两个语句合并为一个

注意 ：

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

数组new

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

 int [] intArray = new int [] {1,2,3,4,5,6,7,8,9,10}; 
 //声明数组文字

• 该数组的长度决定了创建的数组的长度。
• 无需在最新版本的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 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

你也可以使用foreach循环访问java数组

对象阵列

按照以下方式创建对象数组，就像原始类型数据项的数组一样。

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

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

Student arr = new Student[5];

// 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 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

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

编译器会抛出ArrayIndexOutOfBoundsException异常，以表明该数组已被非法索引访问。索引是否定的或者大于或等于数组的大小。

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

多维数组

多维数组是数组的数组，数组中的每个元素都包含其他数组的引用。这些也被称为Jagged Arrays。通过为每个维度附加一组方括号（[]）来创建多维数组。例子：

int [] [] intArray = new int [10] [20]; // 2D数组或矩阵
int [] [] [] intArray = new int [10] [20] [10]; // 3D数组

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 program to demonstrate
// passing of array to method
 
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

从方法返回数组

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

// 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

用于数组的类对象

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

// 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”是类对象的运行时类型签名“组件类型为byte ”。
4. 字符串“[S”是组件类型为short的类对象的数组的运行时类型签名。
5. 字符串“[L”是组件类型为Class的类对象“数组的运行时类型签名”。类名称随后。

数组成员

现在，您知道数组是类的对象，并且数组的直接超类是类Object。数组类型的成员都是以下各项：

• 公共最终字段长度，其中包含数组的组成部分数量。长度可能是正数或零。
• 所有成员从Object类继承; 没有继承的对象的唯一方法是它的克隆方法。
• 公共方法clone（），它覆盖Object类中的clone方法并不引发检查的异常。

克隆数组

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

  // 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 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