1. 数组就是用来储存一批同种类型数据的内存区域（可以理解为容器）。
2. 当已经知道存入的元素值，用静态初始化。

3. 当还不清楚要存入哪些数据，用动态初始化。

   1.静态初始化数组

   静态初始化数组的格式

4. 定义数组的时候直接给数组赋值。

5. 什么类型的数组存放什么类型的数据，否则报错。
6. 数组一旦定义出来，程序执行的过程中，长度、类型就固定了。

//完整格式
数据类型 [ ] 数组名 = new 数据类型 [ ] {元素1,元素2,元素3……};
//简化格式
数据类型 [ ] 数组名 = {元素1,元素2,元素3……};

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

• 数组变量名中储存的是数组在内存中的地址，数组是引用类型。

  数组的访问

• 数组名[索引]

  int[] s ={1,2,3};
  System.out.print(s[0]);//输出：1

  数组的长度属性：length

• 使用方法：数组名.length

  2.动态初始化数组

动态初始化数组的格式

• 定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据。

数据类型 [ ] 数组名 = new 数据类型 [长度];

int[] s = new int[3];
//后赋值
s[0] = 10;
System.out.println(s[0]);//10

动态初始化数组后元素默认值

byte、short、int、char、long类型数组元素默认值都是0
float、double类型数组元素默认值是0.0
boolean类型数组元素的默认值是false、String类型数组元素的默认值是null

3.数组的遍历

• 遍历：就是一个一个数据的访问。

  int arr[] =new int[]{1,2,3};
  for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
  }

public static void main(String[] args) {
        int[] data = new int[5];
        Random r = new Random();
        for (int i = 0; i < data.length; i++) {
            data[i] = r.nextInt(20) + 1;
        }
        Scanner sc = new Scanner(System.in);
        OUT:
        while (true) {
            System.out.println("输入一个1——20的整数进行猜测");
            int guessDate = sc.nextInt();
            for (int i = 0; i < data.length; i++) {
                if (data[i] == guessDate) {
                    System.out.println("你猜中了");
                    break OUT;
                }
            }
            System.out.println("猜测数据数组中不存在");
        }
        for (int i = 0; i < data.length; i++) {
            System.out.println(data[i]);
        }
}

public static void main(String[] args) {
        int[] codes = new int[5];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个员工的工号");
            int code = sc.nextInt();
            codes[i] = code;
        }
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            int index = r.nextInt(codes.length);
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }
        for (int i = 0; i < codes.length; i++) {
            System.out.println(codes[i]);
        }
    }

冒泡排序实现步骤：

1. 定义一个外部循环控制总共需要几轮（数组的长度 - 1）
2. 定义一个内部循环，控制每轮依次往后比较的几个位置（数组的长度 - i - 1）

   //冒泡排序                                                     
   public static void main(String[] args) {                   
    int[] arr = {5, 2, 3, 1};                              
    for (int i = 1; i <= arr.length - 1; i++) {            
        for (int j = 0; j < arr.length - i - 1; j++) {     
            if (arr[j] > arr[j + 1]) {                     
                int temp = arr[j + 1];                     
                arr[j + 1] = arr[j];                       
                arr[j] = temp;                             
            }                    
        }                                                   
    }                                                      
    for (int i = 0; i < arr.length; i++) {                 
        System.out.print(arr[i] + "\t");                   
    }                                                      
   }

   4.数组的内存图

• Java内存分配介绍

• 两个数组变量指向同一个数组对象

5.数组使用常见问题

1. 问题1：如果访问的元素位置超过最大索引，执行时会出现ArrayindexOutOfBoundsException（数组索引越界异常）
2. 问题2：如果数组变量中没有存储数组的地址，而是null，在访问数组信息时会出现NullPointerException（空指针异常）