Java数组

数组对于每一门编程语言来说都是重要的数据结构之一，不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组，用来存储固定大小的同类型元素。

本文将从以下几个内容对数组进行讲解：

1. 数组概述；
2. 数组声明与创建；
3. 数组使用；（重点）
4. 多维数组；
5. Arrays类；
6. 冒泡排序。

一、数组概述

• 数组是相同类型数据的有序集合；

• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

二、数组声明与创建

1. 声明数组

首先必须声明数组变量，才能在程序中使用数组。

以int数组类型为例，下面是声明数组变量的语法：

        int[] nums;  //首选

        int nums2[]; //效果相同，但不是首选

建议使用第一种定义方法，即 int[] nums;。

因为第二种风格来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解Java语言。

2. 创建数组

（1）动态初始化：Java语言使用new操作符来创建数组，语法如下：

        nums = new int[10]; //里面可以存放10个int类型的数字

当然，数组变量的声明与创建，也可以用一条语句完成，如下所示：

        int[] nums = new int[10];

在创建完成之后，我们尝试着输出 nums[1]的值：

        System.out.println(nums[1]);

得到的结果为：

0

显然，我们并没有给nums[1]赋值，那为什么输出nums[1]是有值的呢？原因如下：

数组的动态初始化，包含了数据元素的默认初始化。

即每个数据元素在未赋值之前，都有自己的默认值。

• 这是因为，数组是引用类型，它的元素相当于类的实例变量。因此，数组一经分配空间，其中的每个元素也按照实例变量同样的方式被隐式初始化。
• 数值型变量的默认值是0（或者0.0），布尔型变量的默认值是false，引用类型变量的默认值是null。
• （关于实例变量的内容，可以查看这个链接进行了解：Java变量类型）

（2）静态初始化：直接创建+赋值：

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

一般我们都使用动态初始化，静态初始化先简单了解一下即可。

3. 给数组元素赋值

接下来，我们给这十个数组元素分别赋值：

        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;

4. 计算所有元素和

运用数组，进行一个简单的运算。这里我们了解一个简单的语句 arrays.length,可以获取数组的长度。

        int sum = 0;

        //获取数组长度：arrays.length
        //键盘输入fori，点击回车，可以直接获得for循环语句
        for (int i = 0; i < nums.length ; i++) {
            sum = sum + nums[i];
        }

        System.out.println("总和为"+sum);

得到的结果为：

总和为55

三、数组使用

1. 普通的for循环

输入 数组名.fori，点击回车，使用最普通的for循环语句来操纵数组。

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

        //打印所有数组元素
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+" ");
        }

运行结果如下所示：

1 2 3 4 5 

2. For-Each 循环

输入 arrays.for，点击回车，生成加强型的for循环，即 for (int array : arrays) {}。

这是 JDK 1.5 引进的一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

代码如下所示：

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

        //打印所有数组元素
        for (int array : arrays) {
            System.out.print(array+" ");
        }

运行结果如下：

1 2 3 4 5 

3. 数组作为函数的参数

数组可以作为参数传递给方法。

例如，下面的例子就是一个打印 int 数组中元素的方法:

    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }

我们在main方法中调用 printArray 方法。

        int[] arrays = {1,2,3,4,5};
        printArray(arrays);

运行结果为：

1 2 3 4 5 

4. 数组作为函数的返回值

我们写一个反转数组的方法，并将反转后的数组，作为函数的返回值。

反转数组方法如下所示：

   //反转数组
    public static int[] reverse(int[] arrays){

        int[] result = new int[arrays.length];

        //反转的操作
        for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
            result[j]= arrays[i];
        }

        return result; //将反转后的数组作为返回值
    }

我们在main方法中调用这个方法，并将返回值打印出来：

        int[] reverse = reverse(arrays);
        printArray(reverse);

运行结果如下：

5 4 3 2 1 

四、多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

如下所示，我们定义了一个 3行2列 的二维数组：

        //[3][2]
        /*
            1,0  array[0]
            2,0  array[1]
            3,0  array[2]
         */

        int[][] array = {{1,0},{2,0},{3,0}};

我们可以将这个数组打印出来：

        for (int i = 0; i < array.length ; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println(" ");
        }

运行结果如下所示：

1 0  
2 0  
3 0  

五、Arrays类

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

• 给数组赋值：通过 fill 方法。

• 对数组排序：通过 sort 方法，按升序。

• 比较数组：通过 equals 方法比较数组中元素值是否相等。

• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

• 打印数组：通过toString方法。

首先，我们 import 导入 Arrays 类。

import java.util.Arrays;

利用 Arrays 类里面的 toString 方法，打印数组元素。

        int[] a = {1,2,912456,622412,56621,457,624};
        System.out.println(Arrays.toString(a));

运行结果如下：

[1, 2, 912456, 622412, 56621, 457, 624]

我们再利用 Arrays 类里面的 sort 方法，对数组元素进行排序。

        Arrays.sort(a); //排序
        System.out.println(Arrays.toString(a)); //打印

运行结果如下：

[1, 2, 457, 624, 56621, 622412, 912456]

再尝试使用 Arrays 类里面的 fill 方法，给数组元素赋值。(全部赋值为0)

        Arrays.fill(a, 0); //赋值
        System.out.println(Arrays.toString(a));

运行结果如下：

[0, 0, 0, 0, 0, 0, 0]

fill 方法赋值时，也可以选择元素范围。例如将 2 - 5 号元素赋值为0（fill方法里的2 - 5，包括2号，排除5号），如下所示：

        Arrays.fill(a,2,5,0); // 将 2~5 号元素赋值为0（包括2号，排除5号）
        System.out.println(Arrays.toString(a));

运行结果如下：

[1, 2, 0, 0, 0, 622412, 912456]

其实就是将2、3、4 号 元素赋值为0。

六、冒泡排序

冒泡排序是一种十分常见的数组元素排序方式，在这里做一个简单的介绍。

算法步骤如下：

1. 比较数组中两个相邻的元素，如果 前 > 后 ，则交换它们两个。
2. 比较每一组相邻元素，从开始第一对到结尾的最后一对。一轮完成后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

接下来，我们写一个冒泡排序的方法：

    //冒泡排序
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;

        //外层循环，一共比较几轮
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false; //通过flag标识，减少没有意义的比较
            
            //内层循环，若 前>后，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            
            // 如果此轮比较中，不存在 前>后 的情况，则flag仍为false
            // 全都是 前<后，那就不用再比较了，直接结束该进程
            if (flag==false){
                break;
            }
        }
        return array;
    }

在main方法中调用冒泡排序方法：

        int[] a = {1,5,4,11,88,561,441};

        int[] sort = sort(a); // 调用冒泡排序
        System.out.println(Arrays.toString(sort)); //打印排序后的数组

运行结果如下：

[1, 4, 5, 11, 88, 441, 561]