Java中的数组（基础篇六）

在学习数组之前我们先来了解一下容器，生活中的容器比如水杯是用来装水的，衣柜是装衣服的，Java中的容器是用来存储数据的，将多个数据存储到一起，每个数据称为该容器的元素。

数组：数组就是存储数据长度固定的容器，保存多个数据的数据类型要一致。

1、数组的定义

方式一：

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


int[]  arr = new int[10];
double[] arr1=new double[10]; java

数组定义格式详解：

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

注意：数组有定长特性，长度一旦指定，不可更改。

方式二：

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


int[] arr= new int[]{100,100,100,99,59};// 5

数组定义格式详解：

格式中不显式定义数组长度，长度由后面的元素的个数决定。{元素1,元素2,元素3...}：提前初始化定义数组的元素，可以有任意多个，但元素的类型一定要和前面定义的类型相匹配。

注意：这种格式定义的长度由 大括号里面的元素个数指定，不要显式的定义长度。

举例：

定义存储1，2，3，4，5整数的数组容器。

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

方式三：

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


float[]  arr={1.0f,2.0f};
int[] arr2={1,2,3};//3个元素

小提示：

• 当数据确定时，我们可以使用格式2或者格式3进行定义数组（这两种定义方式也叫静态定义）
• 当数据不确定，我们使用格式1行定义数组（这两种定义方式也叫动态定义）

2、数组的访问

数组的访问是借助索引去访问的。那么什么是索引呢？

索引 （角标，下标）： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

通过索引访问数组中的元素：

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

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

数组的长度属性

每个数组都具有固定的长度，Java中赋予了数组的一个属性​​length​​来表示数组的长度。我们可以通过：​​数组名.length​​ 来获取数组的长度。

int[] arr={1,2,3};
int len=arr.length;//获取数组arr的长度
System.out.println(len); //打印的值为3，即数组arr的长度是3.

由于数组元素编号是从0开始，由此可以推断出，数组的最大索引值为​​数组名.length-1​​。

数组的初始值

2. 整数类型默认是 0
3. 小数类型默认是0.0
4. 字符类型默认是十进制0对应的字符，就是空
5. 布尔类型默认为false
6. (引用数据类型,默认是  null)

小结：

2. 数组就是一个存储数据的容器 (可以是任何数据类型)
3. 任何的数据类型都可以有自己的数组：基本数据类型，引用数据类型都可以有自己的数组(String)
4. 数组的三种定义格式：一种动态声明，两种静态定义
5. 数组的访问使用 索引(角标,下标)：数组名[索引] //相当于一个变量
6. 访问数组的时候不能超出索引边界。[0 , 数组名.length-1]
7. 数组有一个长度属性：length，数组名.length获取值  数组名就是变量名
8. 数组的最后一个元素的索引是length-1
9. 基本数据是有默认值的  0值  整型0,  浮点型0.0,  字符型0对应的字符, 布尔型 false   引用数据类型 null

3、数组的常见操作

• 数组的越界异常

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

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ​​ArrayIndexOutOfBoundsException​​  数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

• 数组空指针异常

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

​​arr = null​​这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出​​NullPointerException​​ 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

空指针异常在内存图中的表现

提示：当一个引用类型的变量值为空的时候，在使用变量的时候就会报出空指针异常。

• 数组的遍历

一般使用循环语句循环取出数组的元素。数组的索引是​​0​​到​​lenght-1​​ ，可以作为循环的条件出现。

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

• 数组反转

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

 实现思想：对称位置数据进行交换。

1. 定义两个变量，保存数组的最小索引和最大索引（对称位置）
2. 两个索引上的元素交换位置
3. 最小索引++，最大索引--，再次交换位置（保证前后位置对称）
4. 最小索引超过了最大索引，数组反转操作结束

public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
/*
      循环中定义变量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]);
}
}

• 数组获取最大值元素

实现思路：

2. 定义变量，保存数组0索引上的元素
3. 遍历数组，获取出数组中的每个元素
4. 将遍历到的元素和保存数组0索引上值的变量进行比较
5. 如果数组元素的值大于了变量的值，变量记录住新的值
6. 数组循环遍历结束，变量保存的就是数组中的最大值

public static void main(String[] args) {
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 };

    //定义变量，保存数组中0索引的元素
    int max =arr[0];

    //遍历数组，取出每个元素
    for (int i = 1; i < arr.length; i++) {
        //遍历到的元素和变量max比较
        //如果数组元素大于max
        if (arr[i] > max) {
            //max记录住大值
            max = arr[i];
        }
    }
    System.out.println("数组最大值是：" + max);
}

 ​