• 连续的存储空间
• 存储多个相同数据类型的值
• 创建数组后不能修改数组的大小（给数组分配空间时，必须指定元素个数）

// 首先创建一个数组，然后将数组的引用赋值给数组变量
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
例子

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

初始化数组，必须将声明，创建和初始化都放在一条语句中，否则会有语法错误

int[] arr1 = new int[2];
a[0] = 10;
a[1] = 20;

int[] arr2 = new int[]{10, 20};

int[] arr3 = {10, 20};

public class Main
{
    public static void main(String[] args)
    {
        int[] arr = {1,2,3,4};
        for(int y = 0; y < arr.length; y++){
            System.out.println(arr[y]);
        }
    }
}

• 数组元素类型 数组名字[][];
• 数组元素类型[][] 数组名字;

int arr1[][];
int[][] arr2;

创建二维数组的时候，可以只声明"行"的长度，而不声明"列"的长度

int a[][];
a = new int[2][4];

int b[][] = new int[2][];
b[0] = new int[2];
b[1] = new int[2];

二维数组每一个元素也是一个数组

int arr1[][] = {{1,3,5},{5,9,10}};

int arr2[][] = new int[][]{{1,3,5},{5,9,10}};

int arr3[][] = new int[2][3];
arr3[0] = new int[]{1,3,5};
arr3[1][0] = 5;
arr[1][1] = 9;
arr[1][2] = 10;

Java也支持不规则的数组，例如二维数组中，不同行的元素个数可以不同

int a[][] = new int[3][];
// 创建二维数组，指定行数，不指定列数
a[0]= new int[5];// 第一行分配5个元素

a[1] = new int[3];// 第二行分配3个元素
a[2] = new int[4];// 第三行分配4个元素

二维不规则数组为例

public class Main {
    public static void main(String[] args) {
        int b[][] = new int[][] { { 1 }, { 2, 3 }, { 4, 5, 6 } }; // 定义二维数组

        for (int k = 0; k < b.length; k++) { // 循环遍历二维数组中第一个索引
            for (int c = 0; c < b[k].length; c++) { // 循环遍历二维数组中第二个索引
                System.out.print(b[k][c] + " "); // 将数组中的元素输出
            }
            System.out.println(); // 输出换行
        }
    }
}

可通过Arrays类的静态方法fill()方法对数组中的元素进行分配，起到填充和替换的效果。fill()方法可将指定的int值分配给int型数组的每个元素
Arrays.fill()(int[] a ,int value)

import java.util.Arrays; //导入java.util.Arrays类

public class Main {
    public static void main(String[] args) {
        int arr[] = new int[5];
        Arrays.fill(arr, 8); // 使用同一个值对数组进行填充

        for (int i = 0; i < arr.length; i++) {
            System.out.println("第" + i + "个元素是：" + arr[i]);
        }
    }
}

1）索引值越界异常ArrayIndexOutOfBoundsException
数组下标的有效范围：0~数组长度-1

2）空指针异常NullPointerException
引用类型变量没有指向任何对象，而访问了对象的属性或调用了对象的方法

• 栈内存：存储部变量。变量一旦出了作用域，就会马上从内存消失，释放内存空间
• 堆内存：存储对象。对象一旦被使用完，不会马上从内存中消失，而是等待垃圾回收器不定时的回收垃圾对象，之后才会释放内存
  
• new关键字创建的对象，JVM都会在堆内存中开辟一个新的空间，创建一个新的对象
• 对象如果没有变量引用，那么就是一个垃圾对象

1. 创建Poetry类，声明一个字符型二维数组，将古诗《春晓》的内容赋值于二维数组，分别用横版和竖版两种方式输出

public class Poetry {
    public static void main(String[] args) {
        char arr[][] = new char[4][]; // 创建一个4行的二维数组
        arr[0] = new char[] { '春', '眠', '不', '觉', '晓' }; // 为每一行赋值
        arr[1] = new char[] { '处', '处', '闻', '啼', '鸟' };
        arr[2] = new char[] { '夜', '来', '风', '雨', '声' };
        arr[3] = new char[] { '花', '落', '知', '多', '少' };
		/* 横版输出 */
        System.out.println("-----横版-----");
        for (int i = 0; i < 4; i++) { // 循环4行
            for (int j = 0; j < 5; j++) { // 循环5列
                System.out.print(arr[i][j]); // 输出数组中的元素
            }
            if (i % 2 == 0) {
                System.out.println(","); // 如果是一、三句，输出逗号
            } else {
                System.out.println("。"); // 如果是二、四句，输出句号
            }
        }
		/* 竖版输出 */
        System.out.println("\n-----竖版-----");
        for (int j = 0; j < 5; j++) { // 列变行
            for (int i = 3; i >= 0; i--) { // 行变列，反序输出
                System.out.print(arr[i][j]); // 输出数组中的元素
            }
            System.out.println(); // 换行
        }
        System.out.println("。，。，"); // 输出最后的标点
    }
}

2. 创建IrregularArrax类，声明一个不规则二维数组，输出数组每行的元素个数及各元素的值

public class IrregularArray {
    public static void main(String[] args) {
        int a[][] = new int[3][]; // 创建二维数组，指定行数，不指定列数
        a[0] = new int[] { 52, 64, 85, 12, 3, 64 }; // 第一行分配5个元素
        a[1] = new int[] { 41, 99, 2 }; // 第二行分配3个元素
        a[2] = new int[] { 285, 61, 278, 2 }; // 第三行分配4个元素

        for (int i = 0; i < a.length; i++) {
            System.out.print("a[" + i + "]中有" + a[i].length + "个元素，分别是：");
            for (int tmp : a[i]) { // foreach循环输出数字中元素
                System.out.print(tmp + " ");
            }
            System.out.println();
        }
    }
}

3. 使用二维数组实现杨辉三角算法

public class Main {
    public static void main(String[] args) {
        // 定义一个长度为10的二维数组
        int[][] arr = new int[10][];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i + 1];
            // 遍历二维数组的列数
            for (int j = 0; j < arr[i].length; j++) {
                // 如果是数组的前两行
                if (i <= 1) {
                    arr[i][j] = 1;
                    continue;
                } else {
                    // 如果是行首或行尾
                    if (j == 0 | j == arr[i].length - 1)
                        arr[i][j] = 1;
                    else
                        arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
                }
            }
        }

        // 输出杨辉三角
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++)
                System.out.print(arr[i][j] + "\t");
            System.out.println();
        }
    }
}