Java中的数组-yiteyi-C++库

Java中的数组是一组类似类型的变量，它们由一个公共名称引用。Java中的数组与C/C++中的数组工作方式不同。下面是关于Java数组的一些要点。

null

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

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

Arrays

创建、初始化和访问阵列

一维数组：

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

type var-name[];ORtype[] var-name;

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

例子：

// both are valid declarationsint 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 ObjectCollection[] ca;  // array of Collection                     // of unknown type

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

在Java中实例化数组

声明数组时，只创建数组的引用。要创建或为数组提供内存，可以创建如下数组：数组的一般形式新由于它适用于一维数组，如下所示：

var-name = new type [size];

在这里类型指定要分配的数据类型，大小确定数组中的元素数，以及 变量名 是链接到数组的数组变量的名称。使用新要分配数组， 必须指定要分配的元素的类型和数量。

例子：

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

或

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

注：

数组中由新将自动初始化为零（对于数字类型）， 错误的 （用于布尔值），或 无效的 （用于参考类型）。参考 Java中的默认数组值
获取阵列需要两个步骤。首先，必须声明所需数组类型的变量。其次，必须使用new分配内存来保存数组，并将其分配给数组变量。因此 在爪哇 , 所有阵列都是动态分配的。

数组文字

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

 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 arrayfor (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 : 10Element at index 1 : 20Element at index 2 : 30Element at index 3 : 40Element at index 4 : 50

您还可以使用 foreach循环 .

Blank Diagram - Page 1 (10)

对象数组

对象数组的创建方式与基本类型数据项数组类似，如下所示。

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

studentArray包含七个内存空间，每个空间的大小与student类相同，其中可以存储七个student对象的地址。必须使用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 amanElement at 1 : 2 vaibhavElement at 2 : 3 shikarElement at 3 : 4 dharmeshElement at 4 : 5 mohit

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

JVM抛出 数组下标越界异常 表示数组已被非法索引访问。索引为负数或大于或等于数组的大小。

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)

输出

多维数组

多维数组是 数组的数组 数组中的每个元素都包含其他数组的引用。这些也被称为锯齿阵列 .多维数组是通过在每个维度上附加一组方括号（[]）来创建的。例如：

int[][] intArray = new int[10][20]; //a 2D array or matrixint[][][] 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

Blank Diagram - Page 1 (13)

将数组传递给方法

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

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

从方法返回数组

通常，方法也可以返回数组。例如，下面的程序从方法返回一个数组 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

数组的类对象

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

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 [Iclass java.lang.Objectclass [Bclass [Sclass [Ljava.lang.String;

说明：

字符串“[I”是具有组件类型的类对象数组的运行时类型签名智力 .”
数组类型的唯一直接超类是 JAVAlang.反对 .
字符串“[B”是具有组件类型的类对象数组的运行时类型签名字节 .”
字符串“[S”是具有组件类型的类对象数组的运行时类型签名短的 .”
字符串“[L”是类对象“具有类的组件类型的数组”的运行时类型签名然后跟随类名。

数组成员

现在，正如您所知，数组是类的对象，数组的直接超类是类对象。数组类型的成员包括以下所有内容：

公共决赛场长，其中包含数组的组件数。长度可以是正或零。
从类对象继承的所有成员；对象的唯一未继承方法是其克隆方法
公共方法 克隆（） ，它将重写类对象中的克隆方法，并不会抛出检查型异常 .

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

数组类型	允许的元素类型
基元类型数组	可以隐式升级为声明类型的任何类型。
对象类型数组	声明的类型对象或其子类对象。
抽象类类型数组	它的子类对象是允许的。
接口类型数组	它的实现类对象是允许的。

阵列的克隆

克隆一维数组（如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]+                                     " "                                     );                       
                                                 }                       
                                                 }                       
                         }                       

输出

false1 2 3

Blank Diagram - Page 1 (11)

然而，多维数组（如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                                     ]);                       
                                   
                                                 }                       
                         }                       

输出

falsetruetrue

Blank Diagram - Page 1 (12)

相关文章：

本文由 Nitsheerendra和Gaurav Miglani .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java