数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。 即：数(数据)组(一组)就是一组数据。

数组是一种数据结构， 用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。

数组的定义

在声明数组变量时， 需要指出数组类型（数据元素类型紧跟 []) 和数组变量的名字。在 Java 中，允许数组长度为 0。数组的下表从0开始。

方式一：

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

int[] arr = new int[3];

方式二：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};

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

方式三：

数据类型[] 数组名 = {元素1,元素2,元素3...};

int[] arr = {1,2,3,4,5};
new int[] { 17, 19, 23, 29, 31, 37 }; // 匿名数组

数组定义格式详解：

• 数组存储的数据类型： 创建的数组容器可以存储什么数据类型
• [] : 表示数组
• 数组名：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组
• new：关键字，创建数组使用的关键字
• 数组存储的数据类型： 创建的数组容器可以存储什么数据类型
• [长度]：数组的长度，表示数组容器中可以存储多少个元素，长度一旦指定，不可更改

创建一个数字数组时， 所有元素都初始化为 0。boolean 数组的元素会初始化为 false。 对象数组的元素则初始化为一个特殊值 null，这表示这些元素（还）未存放任何对象。

数组的赋值机制

基本数据类型赋值，这个值就是具体的数据，而且相互不影响。

int n1 = 80;
int n2 = n1;
n1 = 100;
System.out.println(n1); // 100
System.out.println(n2); // 80

数组在默认情况下是引用传递，赋的值是地址。

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;
arr2[0] = 10;
for (int i = 0; i < arr1.length; i++) {
    System.out.print(arr1[i] + "\t");   // 10  2  3
}

数组的常见操作

访问数组

• 索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
• 数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为： 数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为 数组名.length-1 。

索引访问数组中的元素：

• 数组名[索引] = 数值，为数组中的元素赋值
• 变量 = 数组名[索引]，获取出数组中的元素

public static void main(String[] args) { 
    //定义存储int类型数组，赋值元素1，2，3，4，5 
    int[] arr = {1,2,3,4,5}; 
    //为0索引元素赋值为6 
    arr[0] = 6; 
    //获取数组0索引上的元素 
    int i = arr[0]; 
    System.out.println(i); 
    //直接输出数组0索引元素 
    System.out.println(arr[0]); 
}

forEach循环

foreach 循环语句的循环变量将会遍历数组中的每个元素， 而不需要使用下标值。

for (变量 : collection) {
    循环体
}

collection 表达式必须是一个数组或者是一个实现了 Iterable 接口的类对象。

数组越界异常

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。

public static void main(String[] args) { 
    int[] arr = {1,2,3}; 
    System.out.println(arr[3]); 
}

数组获取最大值元素

从数组的所有元素中找出最大值。

public static void main(String[] args) {
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
    //定义变量，保存数组中0索引的元素
    int max = arr[0];
    //遍历数组，取出每个元素
    for (int i = 0; i < arr.length; i++) {
        //遍历到的元素和变量max比较
        //如果数组元素大于max
        if (arr[i] > max) {
            //max记录住大值
            max = arr[i];
        }
    }
    System.out.println("数组最大值是： " + max);
}

数组反转

数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1。

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*
    规律：
    第一步：将arr[0]和arr[4]交换 得到{5, 2, 3, 4, 1}
    第二步：将arr[1]和arr[3]交换 得到{5, 4, 3, 2, 1}
    由此可得：
    循环中定义变量min=0最小索引
    max=arr.length‐1最大索引
    min++,max‐‐
    */
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
        //利用第三方变量完成数组中的元素交换
        int temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    // 反转后，遍历数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

数组拷贝

如果希望将一个数组的所有值拷贝到一个新的数组中，要使用 Arrays 类的 copyOf 方法：

// 第 2 个参数是新数组的长度。
// 可以更改大小，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。
// 如果大于原始数组长度，则为默认值。
int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length);

命令行参数

每一个 Java 应用程序都有一个带 String arg[] 参数的 main 方法。这个参数表明 main 方法将接收一个字符串数组，也就是命令行参数。

public class Message{
    public static void main(String[] args) {
        if (args.length == 0 || args[0].equals("_h"))
            System.out.print("Hello,");
        else if (args[0].equa1s("-g"))
            System.out.print("Goodbye ,"); 
        for (int i = 1; i < args.length; i++)
            System.out.print(" " + args[i]);
        System.out.println("!");
    }
}

数组排序

可以使用 Arrays 类中的 sort 方法对数值型数组进行排序：

int[] a = new int[10000];
...
Arrays.sort(a);

这个方法使用了优化的快速排序算法。快速排序算法对于大多数数据集合来说都是效率比较高的。

二维数组

一维数组的每个元素是一维数组，就构成二维数组。多维数组将使用多个下标访问数组元素， 它适用于表示表格或更加复杂的排列形式。

声明方式

int[][] y
int[] y[]
int y[][]

double[][] balances;
balances = new double[NYEARS] [NRATES]:
int[][] arr = {
    {0, 0, 0, 0, 0, 0}, 
    {0, 0, 1, 0, 0, 0}, 
    {0, 2, 0, 3, 0, 0}, 
    {0, 0, 0, 0, 0, 0}
};
// 遍历
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}

数组被初始化后，就可以利用两个方括号访问每个元素，balances[i][j]。

动态初始化

方式一

类型[][] 数组名 = new 类型[大小][大小];

比如：int arr[][]=new int[2][3];

方式二

类型 数组名[][];数组名 = new 类型[大小][大小];

方式三

类型[][] 数组名 = new 类型[大小][];

数组名[索引] = new 类型[大小];

方式四

类型 数组名[][] = {{值1, 值2...}, {值1, 值2...}, {值1, 值2...}};

多维数组

int[][][][][][] aaa = new int[5][8][3][10][6][2];