2.6 数组

1. 数组的创建和使用

数组是名称相同，下标不同的一组变量，用来存储一组类型相同的数据。数组的使用一般需要三个步骤。

• 声明数组，声明数组名称和元素的数据类型。

• 创建数组，为数组元素分配存储空间。

• 使用数组，对数组元素操作。

（1）声明数组

数组声明格式如下：

elementType[ ] arrayName;  
例如：double[ ] scores;

其中，elementType为数组元素类型，可以是基本数据类型也可以是引用数据类型；arrayName为数组名。

（2）创建数组

数组声明仅仅声明一个数组对象引用，而创建数组是为数组的每个元素分配存储空间，一般格式为：

arrayName = new elementType[arraySize];   //arraySize是元素个数
例如：scores = new double[5];            //scores数组包含5个double类型元素

数组的声明和创建可以写在一个语句中：

elementType[ ] arrayName = new elementType[arraySize];
例如：double[ ] scores = new double[5];

（3）使用数组

数组元素的使用方式是：

arrayName [index]    
例如：scores[1]

其中，index为数组元素下标或索引，下标从0到数组长度-1。数组作为对象提供了一个length成员变量，它表示数组元素个数，访问该成员变量的方法为arrayName.length。

（4）数组默认值

当new运算符创建一个数组时，系统会为数组元素分配存储空间，为数组元素指定默认值。

• 数值型，数组元素的默认值是0。

• 字符型，数组元素的默认值是'\u0000'（空字符）。

• 布尔型，数组元素的默认值是false。

• 引用类型，数组元素的默认值是null。

（5）静态初始化数组

声明数组同时可以使用初始化器对数据元素初始化，在一对大括号中给出数组的每个元素值，这种初始化称为静态初始化。

double[ ] scores = new double[ ]{ 1.1 , 2.0 , 3.0 };
//简化格式
double[ ] scores = { 1.1 , 2.0 , 3.0 };

2. 数组案例

（1）案例1

编写程序，从键盘输入5个整数存到一个数组中，输出数组的值。

• 使用for循环输出

public static void main(String[] args) {
    int[] nums = new int[5];
    Scanner input = new Scanner(System.in);
    //输入
    for(int i=0;i<5;i++){
        System.out.println("请输入第" + (i+1) + "个整数：");
        nums[i] = input.nextInt();
    }
    //输出
    for(int i=0;i< nums.length;i++){
        System.out.println("数组第" + (i+1) + "个整数是："+nums[i] );
    }
}

• 使用增强for循环输出

public static void main(String[] args) {
    int[] nums = new int[5];
    Scanner input = new Scanner(System.in);
    //输入
    for(int i=0;i<5;i++){
        System.out.println("请输入第" + (i+1) + "个整数：");
        nums[i] = input.nextInt();
    }
    //输出
    for(int num : nums){
       System.out.println(num);
    }
}

（2）案例2

编写程序，求整数数组{1,2,3,4,5}的和并打印输出。

public static void main(String[] args) {
    int[] nums = {1,2,3,4,5};
    int sum = 0;
    for(int i=0;i<nums.length;i++){
        sum += nums[i];
    }
    System.out.println("数组的和为：" + sum);
}

（3）案例3

编写程序，初始化整数数组{1,2,3,4,5}和整数数组{6,7,8,9,10}，计算两个数组元素对应下标的和，并输出求和后数组。

public static void main(String[] args) {
    int[] nums1 = {1,2,3,4,5};
    int[] nums2 = {6,7,8,9,10};
    int[] nums = new int[nums1.length];
    for(int i=0;i<nums1.length;i++){
        nums[i] = nums1[i] + nums2[i];
    }
    for(int i = 0;i < nums.length;i++){
        System.out.println("下标为" + i + "的和为：" + nums[i]);
    }
}

3. 冒泡排序法

在实际开发中，数组常用的操作有排序，数组的排序方法有很多，下面讲解一种比较常见的数组排序算法——冒泡排序。所谓冒泡排序，就是不断地比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程和水中气泡上升的原理相似。

（1）冒泡排序步骤

第1步，从第一个元素开始，将相邻的两个元素依次进行比较，直到最后两个元素完成比较。如果前一个元素比后一个元素大，则交换它们的位置。整个过程完成后，数组中最后一个元素自然就是最大值，这样也就完成了第一轮比较。

第2步，除了最后一个元素，将剩余的元素继续进行两两比较，过程与第一步相似，这样就可以将数组中第二大的元素放在了倒数第二个位置。

第3步，以此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一对元素需要比较为止。

（2）案例实现

编写程序，从键盘输入5个整数存到一个数组中，对数组从小到大进行排序，输出排序后的数组（使用冒泡排序算法）。

public static void main(String[] args) {
    int[] nums = new int[5];
    Scanner input = new Scanner(System.in);
    //输入
    for(int i=0;i<5;i++){
        System.out.print("请输入第" + (i+1) + "个整数：");
        nums[i] = input.nextInt();
    }
    //冒泡排序法排序（从小到大）
    for(int i = 1;i < nums.length;i++){ //外层循环定义需要比较的轮数（两数对比，要比较n-1轮）
        for(int j=0;j < nums.length - i;j++){ //内层循环定义第i轮需要比较的两个数
            if(nums[j] > nums[j+1]){ // 比较相邻元素
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
    //输出排序结果
    System.out.print("排序后结果为：");
    for(int num : nums){
        System.out.print(num + "\t");
    }
}

4. Arrays类

Arrays类定义若干静态方法对数组操作，包括对数组排序、在已排序的数组中查找指定元素、复制数组元素、比较两个数组是否相等、将一个值填充到数组的每个元素中。

（1）数组的排序

使用Arrays的sort( )方法可以对数组元素排序，对于基本数据类型，按数据的升序排序。

编写程序，从键盘输入5个整数存到一个数组中，对数组从小到大进行排序，输出排序后的数组（使用Arrays.sort( )实现）。

public static void main(String[] args) {
    int[] nums = new int[5];
    Scanner input = new Scanner(System.in);
    //输入
    for(int i=0;i<5;i++){
        System.out.print("请输入第" + (i+1) + "个整数：");
        nums[i] = input.nextInt();
    }
    //排序
    Arrays.sort(nums);
    for(int num : nums){
        System.out.println(num);
    }
}

（2）数组的比较

使用Arrays的equals( )方法可以比较两个数组，比较两个数组对应元素是否相同。

使用数组对象的equals( )方法用来比较两个引用是否相同。

public static void main(String[] args) {
    int[] nums1 = {1,2,3,4,5};
    int[] nums2 = nums1;
    int[] nums3 = {1,2,3,4,5};
    System.out.println("nums1地址：" + nums1);
    System.out.println("nums2地址：" + nums2);  //nums1 与 nums2 地址相同
    System.out.println("nums3地址：" + nums3);  //nums1 与 nums3 地址不同
    //Arrays.equals()比较:比较两个数组对应元素是否相同
    System.out.println(Arrays.equals(nums1,nums2));  //true
    System.out.println(Arrays.equals(nums1,nums3));  //true
    //对象的equals()比较:比较两个引用是否相同
    System.out.println(nums1.equals(nums2)); //true
    System.out.println(nums1.equals(nums3)); //false
}

5. 二维数组

多维数组可以简单地理解为在数组中嵌套数组，即数组的元素是一个数组。在程序中比较常见的多维数组就是二维数组，二维数组就是指维数为2的数组，即数组有两个索引。二维数组的逻辑结构按行列排列，两个索引分别表示行列，通过行列可以准确标识一个元素。

（1）二维数组的声明

String[ ][ ] cities;

（2）二维数组的创建

String[ ][ ] cities = new String[2][3];

（3）二维数组的使用

cities[index1][index2]，其中index1和index2为数组元素下标。

（4）静态初始化二维数组

String[][] cities = {{"济南","青岛","潍坊"},{"郑州","开封","洛阳"}};

（5）二维数组案例

定义2*3的二维数组，分别输入"济南","青岛","潍坊"和"郑州","开封","洛阳"存储到二维数组，并对二维数组输出。

public static void main(String[] args) {
    String[][] cities = new String[2][3];
    Scanner input = new Scanner(System.in);
    //输入
    for(int i=0;i<2;i++){
        for(int j=0;j<3;j++){
            System.out.print("请输入第" + (i+1) +"组城市名称：");
            cities[i][j] = input.next();
        }
    }
    //输出
    for (int i=0;i<cities.length;i++){
        System.out.println("城市列表：" + Arrays.toString(cities[i]));
        for(int j=0;j<cities[i].length;j++){
            System.out.println("城市名称：" + cities[i][j]);
        }
    }
}

6.练习

编写程序，从键盘输入5个整数存到一个数组中，找出最大值、最小值并打印输出（要求使用for循环判断）。

public static void main(String[] args) {
    int[] nums = new int[5];
    Scanner input = new Scanner(System.in);
    //输入
    for(int i=0;i<5;i++){
        System.out.print("请输入第" + (i+1) + "个整数：");
        nums[i] = input.nextInt();
    }
    int max = nums[0];
    int min = nums[0];
    for(int i=1;i<nums.length;i++){
        if(nums[i] > max){
            max = nums[i];
        }
        if(nums[i] < min){
            min = nums[i];
        }
    }
    System.out.println("最大值是：" + max);
    System.out.println("最小值是：" + min);
}