JAVA基础，数组

数组（Array）

什么是数组

数组是最常见的一种数据结构，它是相同类型的用一个标识符封装到一起的基本类型数据序列或者对象序列。数组使用一个统一的数组名和不同的下标来唯一确定数组中的元素。实质上，数组是一个简单的线性序列，因此访问速度很快。

在某些情况下，虽然可以使用单个变量来存储信息，但是如果需要存储的信息较多（例如存储 50 名学生的成绩），这时再依次创建变量声明并赋值显得非常麻烦。

随着处理的信息量越来越大，工作也就越来越烦琐，这时可以使用数组或集合来存储信息。通过使用数组，可以在很大程度上缩短和简化程序代码，从而提高应用程序的效率。

数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

在计算机语言中数组是非常重要的集合类型，大部分计算机语言中数组具有如下三个基本特性：

1. 一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型。
2. 有序性：数组中的元素是有序的，通过下标访问。
3. 不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变。

总的来说，数组具有以下特点：

• 数组可以是一维数组、二维数组或多维数组。
• 数值数组元素的默认值为 0，而引用元素的默认值为 null。
• 数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。
• 数组元素可以是任何类型，包括数组类型。
• 数组类型是从抽象基类 Array 派生的引用类型。

在 Java 中数组的下标是从零开始的，很多计算机语言的数组下标也从零开始。Java 数组下标访问运算符是中括号，如 intArray[0]，表示访问 intArray 数组的第一个元素，0 是第一个元素的下标。Java 中的数组本身是引用数据类型，它的长度属性是 length。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，…，number99。

一个数组包括：数组名、下标（索引）、元素、数组的长度

数组也是一种数据类型

Java 的数组要求所有的数组元素具有相同的数据类型。因此，在一个数组中，数组元素的类型是唯一的，即一个数组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据。

因为 Java 语言是面向对象的语言，而类与类之间可以支持继承关系（从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为），这样可能产生一个数组里存放多种数据类型的假象。例如有一个水果数组，要求每个数组元素都是水果，实际上数组元素既可以是苹果，也可以是香蕉（苹果、香蕉都继承了水果，都是一种特殊的水果），但这个数组的数组元素的类型还是唯一的，只能是水果类型。

一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。即使把某个数组元素的数据清空，但它所占的空间依然被保留，依然属于该数组，数组的长度依然不变。

Java 的数组既可以存储基本类型的数据，也可以存储引用类型的数据，只要所有的数组元素具有相同的类型即可。

值得指出的是，数组也是一种数据类型，它本身是一种引用类型。例如 int 是一个基本类型，但 int[]（这是定义数组的一种方式）就是一种引用类型了。

int[] 是一种类型吗？怎么使用这种类型呢？

没错，int[] 就是一种数据类型，与 int 类型、String 类型相似，一样可以使用该类型来定义变量，也可以使用该类型进行类型转换等。使用 int[] 类型来定义变量、进行类型转换时与使用其他普通类型没有任何区别。int[] 类型是一种引用类型，创建 int[] 类型的对象也就是创建数组，需要使用创建数组的语法。

一维数组

当数组中每个元素都只带有一个下标时，这种数组就是“一维数组”。一维数组（one-dimensional array）实质上是一组相同类型数据的线性集合，是数组中最简单的一种数组。

数组是引用数据类型，引用数据类型在使用之前一定要做两件事情：声明和初始化。

创建数组

数组本身是引用数据类型，数组的元素可以是任意数据类型，包括基本数据类型和引用数据类型。

创建数据对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。

需要注意的是：数组的长度一旦确定，就不能修改。

Java语言使用new操作符来创建数组，语法：

type[] arrayName = new type[arraySize]; // 数据类型[] 数组名;

上面的语法语句做了两件事：

• 使用 dataType[arraySize] 创建了一个数组。
• 把新创建的数组的引用赋值给变量 arrayRefVar。

创建数组还有另一种语法：

type arrayName[];     // 数据类型 数组名[];

可见数组的声明有两种形式：一种是中括号”[]“跟在元素数据类型之后，另一种是中括号”[]“跟在变量名之后。

对于以上两种语法格式而言，Java 更推荐采用第一种声明格式，因为第一种格式不仅具有更好的语意，而且具有更好的可读性。对于第一种格式type[] arrayName，很容易理解这是定义一个变量，其中变量名是 arrayName，而变量类型是 type[]。

前面已经指出：type[] 确实是一种新类型，与 type 类型完全不同（例如 int 类型是基本类型，但 int[] 是引用类型）。因此，这种方式既容易理解，也符合定义变量的语法。但第二种格式type arrayName[]的可读性就差了，看起来好像定义了一个类型为 type 的变量，而变量名是 arrayName[]，这与真实的含义相去甚远。

可能有些读者非常喜欢type arrayName[]这种定义数组的方式，这可能是因为早期某些计算机读物的误导，从现在开始最好就不要再使用这种糟糕的方式了。

提示：Java 的模仿者 C# 就不再支持type arrayName[]这种语法，它只支持第一种定义数组的语法。越来越多的语言不再支持type arrayName[]这种数组定义语法。

以上两种格式都可以声明一个数组，其中的数据类型既可以是基本数据类型，也可以是引用数据类型。数组名可以是任意合法的变量名。声明数组就是要告诉计算机该数组中数据的类型是什么。例如：

int[] score;    // 存储学生的成绩，类型为整型
double[] price;    // 存储商品的价格，类型为浮点型
String[] name;    // 存储商品名称，类型为字符串型

在声明数组时不需要规定数组的长度，例如：

int score[10];    // 这是错误的

注意：在声明数组变量时千万不要漏写[]。

分配空间

声明了数组，只是得到了一个存放数组的变量，并没有为数组元素分配内存空间，不能使用。因此要为数组分配内存空间，这样数组的每一个元素才有一个空间进行存储。

简单地说，分配空间就是要告诉计算机在内存中为它分配几个连续的位置来存储数据。在 Java 中可以使用 new 关键字来给数组分配空间。分配空间的语法格式如下：

arrayName = new type[size];    // 数组名 = new 数据类型[数组长度];

其中，数组长度就是数组中能存放的元素个数，显然应该为大于 0 的整数，例如：

score = new int[10];
price = new double[30];
name = new String[20];

这里的 score 是已经声明过的 int[] 类型的变量，当然也可以在声明数组时就给它分配空间，语法格式如下：

type[] arrayName = new type[size];    // 数据类型[] 数组名 = new 数据类型[数组长度];

例如，声明并分配一个长度为 5 的 int 类型数组 arr，代码如下：

int[] arr = new int[5];

执行后 arr 数组在内存中的格式如图所示。

在图 中 arr 为数组名称，方括号“[]”中的值为数组的下标。数组通过下标来区分数组中不同的元素，并且下标是从 0 开始的。因此这里包含 5 个元素的 arr 数组最大下标为 4。

注意：一旦声明了数组的大小，就不能再修改。这里的数组长度也是必需的，不能少。

尽管数组可以存储一组基本数据类型的元素，但是数组整体属于引用数据类型。当声明一个数组变量时，其实是创建了一个类型为“数据类型[]”（如 int[]、double[]、String[]）的数组对象，它具有表所示的方法和属性。

方法	名称	返回值
clone()	Object
equals(Object obj)	boolean
getClass()	Class<?>
hashCode()	int
notify()	void
notify All()	void
toString()	String
wait()	void
wait(long timeout)	void
wait(long timeout,int nanos)	void
属性	length	int

初始化一维数组

Java 语言中数组必须先初始化，然后才可以使用。所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。

能不能只分配内存空间，不赋初始值呢？

不行，一旦为数组的每个数组元素分配了内存空间，每个内存空间里存储的内容就是该数组元素的值，即使这个内存空间存储的内容为空，这个空也是一个值（null）。不管以哪种方式来初始化数组，只要为数组元素分配了内存空间，数组元素就具有了初始值。初始值的获得有两种形式，一种由系统自动分配，另一种由程序员指定。

数组在初始化数组的同时，可以指定数组的大小，也可以分别初始化数组中的每一个元素。在 Java 语言中，初始化数组有 3 种方式。

使用 new 指定数组大小后进行初始化

使用 new 关键字创建数组，在创建时指定数组的大小。语法如下：

type[] arrayName = new int[size];

创建数组之后，元素的值并不确定，需要为每一个数组的元素进行赋值，其下标从 0 开始。

例：创建包含 5 个元素的 int 类型的数组，然后分别将元素的值设置为 1、2、3、5 和 8。代码如下：

int[] number = new int[5];
number[0] = 1;
number[1] = 2
;number[2] = 3;
number[3] = 5;
number[4] = 8;

如果程序员只指定了数组的长度，那么系统将负责为这些数组元素分配初始值。指定初始值时，系统按如下规则分配初始值。

• 数组元素的类型是基本类型中的整数类型（byte、short、int 和 long），则数组元素的值是 0。
• 数组元素的类型是基本类型中的浮点类型（float、double），则数组元素的值是 0.0。
• 数组元素的类型是基本类型中的字符类型（char），则数组元素的值是‘\u0000’。
• 数组元素的类型是基本类型中的布尔类型（boolean），则数组元素的值是 false。
• 数组元素的类型是引用类型（类、接口和数组），则数组元素的值是 null。

使用 new 指定数组元素的值

使用上述方式初始化数组时，只有在为元素赋值时才确定值。可以不使用上述方式，而是在初始化时就已经确定值。语法如下：

type[] arrayName = new type[]{
   值 1,值 2,值 3,值 4,• • •,值 n};

例 ：使用 new 直接指定数组元素的值。代码如下：

int[] number = new int[]{
   1, 2, 3, 5, 8};

注意：不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值，这样会造成代码错误。例如下面代码：

int[] number = new int [5] {
   1,2,3,4,5};

直接指定数组元素的值

在上述两种方式的语法中，type 可以省略，如果已经声明数组变量，那么直接使用这两种方式进行初始化。如果不想使用上述两种方式，那么可以不使用 new 直接指定数组元素的值。语法如下：

type[] arrayName = {
   值 1,值 2,值 3,...,值 n};

例：在前面例子的基础上更改代码，直接使用上述语法实现 number 数组的初始化。代码如下：

int[] number = {
   1,2,3,5,8};

使用这种方式时，数组的声明和初始化操作要同步，即不能省略数组变量的类型。如下的代码就是错误的：

int[] number;number = {
   1,2,3,5,8};

数组的访问

获取单个元素

获取单个元素是指获取数组中的一个元素，如第一个元素或最后一个元素。获取单个元素的方法非常简单，指定元素所在数组的下标即可。语法如下：

arrayName[index];

其中，arrayName 表示数组变量，index 表示下标，下标为 0 表示获取第一个元素，下标为 array.length-1 表示获取最后一个元素。当指定的下标值超出数组的总长度时，会拋出 ArraylndexOutOfBoundsException 异常。

例：获取 number 数组中的第一个元素、最后一个元素和第六个元素，并将元素的值输出。代码如下：

int[] number = {
   1,2,3,5,8};
System.out.println("获取第一个元素："+number[0]);
System.out.println("获取最后一个元素："+number[number.length-1]);
System.out.println("获取第6个元素："+number[5]);

执行上述代码，输出结果如下所示：

获取第一个元素：1
获取最后一个元素：8
java.lang.ArrayIndexOutOfBoundsException: 5

我们一共存入了 5 个值，所以下标的取值为 0~4。因为 number[5] 取出的内容超过了这个下标，所以输出结果会提示数组索引超出绑定异常（ArrayIndexOutOfBoundsException）。这一点是在使用数组中是经常出现的问题，大家在编写程序时应该引起注意。

例：编写一个 Java 程序，使用数组存放录入的 5 件商品价格，然后使用下标访问第 3 个元素的值。

import java.util.Scanner;
public class Test06 {
       
    public static void main(String[] args) {
           
        int[] prices = new int[5]; // 声明数组并分配空间        
        Scanner input = new Scanner(System.in); // 接收用户从控制台输入的数据       
        for (int i = 0; i < prices.length; i++) {
               
            System.out.println("请输入第" + (i + 1) + "件商品的价格：");            
            prices[i] = input.nextInt(); // 接收用户从控制台输入的数据        
        }        
        System.out.println("第 3 件商品的价格为：" + prices[2]);    
    }
}

上述代码的“int[] prices = new int[5]”语句创建了需要 5 个元素空间的 prices 数组，然后结合 for 循环向数组中的每个元素赋值。

注意：在 Java 中取得数组的长度（也就是数组元素的长度）可以利用“数组名称.length”，返回一个 int 型数据。

数组的索引从 0 开始，而 for 循环中的变量 i 也从 0 开始，因此 score 数组中的元素可以使用 scored 来表示，大大简化了代码。最后使用 prices[2] 获取 prices 数组的第 3 个元素，最终运行效果如下所示。

请输入第1件商品的价格：
5
请输入第2件商品的价格：
4
请输入第3件商品的价格：
6
请输入第4件商品的价格：
4
请输入第5件商品的价格：
8
第 3 件商品的价格为：6

获取全部元素

当数组中的元素数量不多时，要获取数组中的全部元素，可以使用下标逐个获取元素。但是，如果数组中的元素过多，再使用单个下标则显得烦琐，此时使用一种简单的方法可以获取全部元素——使用循环语句。

下面利用 for 循环语句遍历 number 数组中的全部元素，并将元素的值输出。代码如下：

int[] number = {
   1,2,3,5,8};
for (int i=0;i<number.length;i++) {
       
    System.out.println("第"+(i+1)+"个元素的值是："+number[i]);
}

除了使用 for 语句，还可以使用 foreach 遍历数组中的元素，并将元素的值输出。代码如下:

for(int val:number) {
       
    System.out.print("元素的值依次是："+val+"\t");
}

二维数组（了解即可）

为了方便组织各种信息，计算机常将信息以表的形式进行组织，然后再以行和列的形式呈现出来。二维数组的结构决定了其能非常方便地表示计算机中的表，以第一个下标表示元素所在的行，第二个下标表示元素所在的列。

创建二维数组

在 Java 中二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。Java 并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。声明二维数组的语法如下：

type arrayName[][];    // 数据类型 数组名[][];  
//或   
type[][] arrayName;    // 数据类型[][] 数组名;

其中，type 表示二维数组的类型，arrayName 表示数组名称，第一个中括号表示行，第二个中括号表示列。

下面分别声明 int 类型和 char 类型的数组，代码如下：

int[][] age;char[][] sex;

初始化二维数组

二维数组可以初始化，和一维数组一样，可以通过 3 种方式来指定元素的初始值。这 3 种方式的语法如下：

type[][] arrayName = new type[][]{
   值 1,值 2,值 3,…,值 n};    // 在定义时初始化
type[][] arrayName = new type[size1][size2];    // 给定空间，在赋值
type[][] arrayName = new type[size][];    // 数组第二维长度为空，可变化

例：使用第一种方式声明 int 类型的二维数组，然后初始化该二维数组。代码如下：

int[][] temp = new int[][]{
   {
   1,2},{
   3,4}};

上述代码创建了一个二行二列的二维数组 temp，并对数组中的元素进行了初始化。图所示为该数组的内存结构。

使用第二种方式声明 int 类型的二维数组，然后初始化该二维数组。代码如下：

int[][] temp = new int[2][2];

使用第三种方式声明 int 类型的二维数组，并且初始化数组。代码如下：

int[][] temp = new int[2][];

获取单个元素

在上部分使用的前 2 种方式创建并初始化了一个二行二列的 int 类型数组 temp。当需要获取二维数组中元素的值时，也可以使用下标来表示。语法如下：

arrayName[i-1][j-1];

其中，arrayName 表示数组名称，i 表示数组的行数，j 表示数组的列数。例如，要获取第二行第二列元素的值，应该使用 temp[1][1]来表示。这是由于数组的下标起始值为 0，因此行和列的下标需要减 1。

例：通过下标获取 class_score 数组中第二行第二列元素的值与第四行第一列元素的值。代码如下：

public static void main(String[] args) {
       
    double[][] class_score = {
   {
   10.0,99,99},{
   100,98,97},{
   100,100,99.5},{
   99.5,99,98.5}};    
    System.out.println("第二行第二列元素的值："+class_score[1][1]);   
    System.out.println("第四行第一列元素的值："+class_score[3][0]);
}

执行上述代码，输出结果如下：

第二行第二列元素的值：98.0
第四行第一列元素的值：99.5

获取全部元素

在一维数组中直接使用数组的 length 属性获取数组元素的个数。而在二维数组中，直接使用 length 属性获取的是数组的行数，在指定的索引后加上 length（如 array[0].length）表示的是该行拥有多少个元素，即列数。

如果要获取二维数组中的全部元素，最简单、最常用的办法就是使用 for 语句。在一维数组全部输出时，我们使用一层 for 循环，而二维数组要想全部输出，则使用嵌套 for 循环（2 层 for 循环）。

例 ：使用 for 循环语句遍历 double 类型的 class_score 数组的元素，并输出每一行每一列元素的值。代码如下：

public static void main(String[] args) {
       
    double[][] class_score = {
    {
    100, 99, 99 }, {
    100, 98, 97 }, {
    100, 100, 99.5 }, {
    99.5, 99, 98.5 } };   
    for (int i = 0; i < class_score.length; i++) {
    // 遍历行        
        for (int j = 0; j < class_score[i].length; j++) {
              
            System.out.println("class_score[" + i + "][" + j + "]=" + class_score[i][j]);        
        }    
    }
}

上述代码使用嵌套 for 循环语句输出二维数组。在输出二维数组时，第一个 for 循环语句表示以行进行循环，第二个 for 循环语句表示以列进行循环，这样就实现了获取二维数组中每个元素的值的功能。

执行上述代码，输出结果如下所示。

class_score[0][0]=100.0
class_score[0][1]=99.0
class_score[0][2]=99.0
class_score[1][0]=100.0
class_score[