Java基础（十三）---- 数组的详细介绍

---

一、了解数组(Array)

1.数组的相关概念

定义：数组是一种容器，可以同时存放多个类型相同的数据
特点：
    1.数组是一种引用数据类型
    2.数组中的多个数据的数据类型必须统一
    3.数组的长度在运行期间不可以改变
数组的初始化：在内存中创建一个数组，并向其中赋予一些默认值

2.数组的初始化

动态初始化(指定长度)

数据类型[] 数组名称 = new 数据类型[数组长度];
/*
 含义解析：
       左侧数据类型：数组中保存的数据必须全部为这个类型
       左侧中括号：代表这是一个数组
       右侧的new：代表创建一个数组
       右侧的数据类型：必须和左侧一样
       右侧中括号中的长度：代表数组可以保存多少数据
*/

//创建一个数组，可以保存 10 个 int 类型数据
int[] array01 = new int[10];
        
//创建一个数组，可以保存 5 个 String 类型的数据
String[] array02 = new String[5];

//动态初始化分为两个步骤创建一个长度为 5 的 int 类型数组
int[] array03;
array03 = new int[5];

【tips】
使用动态初始化定义数组时，不同的数据类型会有对应的默认值

数据类型	默认值
整数类型	0
浮点类型	0.0
字符类型	‘\u0000’
布尔类型	false
引用类型	null

静态初始化定义数组时也有默认值但是由于在定义时对数组进行了赋值，默认值被立马进行了覆盖

静态初始化(指定内容)

标准格式

数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，元素3...};
/*
注意：静态初始化虽然没有直接定义长度，
但是可以间接从大括号中的元素数量推算出来
*/

//创建一个int类型数组，存放数据10，20，30
int[] array01 = new int[] {10,20,30};
        
//创建一个String类型数组，存放数据"我是","小明"
String[] array02 = new String[] {"我是","小明"};

//静态初始化(标准格式)分为两个步骤创建数组，存放数据1，2，3
int[] array03;
array03 = new int[]{1,2,3};

省略格式

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

//创建一个int类型数组，存放数据1，2，3，4，5
int[] array01 = {1,2,3,4,5};

//静态初始化(省略格式)不可以拆分为两个步骤创建数组
/*
错误写法
int[] array02;
array02 = {1,2,3};
*/

【tips】
数组使用建议：
1.如果不确定数组内容用动态初始化
2.已经确定数组内容使用静态初始化

3.数组元素的获取与赋值

数组元素的获取

//格式
数组名称[索引值];
//索引值是一个整型数字，代表数组中元素的编号
//索引值从 0 开始，数组第n个元素的索引值为（n-1）

//使用静态初始化省略格式定义一个数组
int[] array = {1,2,3,4,5};

//打印数组名称
System.out.println(array);//结果为：[I@1540e19d 
/*
结果分析：
"["代表"array"是一个数组
"I"代表数组类型为int型
"@"之后的十六进制内容代表了数组的内存地址值
*/

//打印数组的第三个元素
System.out.println("第三个元素是："+array[2]);//结果为：第三个元素是：3

//将获取到的值赋值给一个变量
int num = array[3];
System.out.println(num);//结果为：4

对数组元素进行赋值

//格式
数组名称[索引值] = 数据;

//使用动态初始化定义一个数组
int[] array = new int[3];
//对第（2+1）个元素赋值
array[2] = 120;
System.out.println(array[0]);//0
System.out.println(array[1]);//0
System.out.println(array[2]);//120

二、数组与内存

1.Java中内存的划分

Java的内存需要划分为五个部分

1.栈(Stack):存放方法中的局部变量。方法一定在栈中运行
        局部变量：方法的参数，或者方法内部的变量
2.堆(Heap):凡是 new 出来的东西，都在堆中
        堆内存里的东西都有一个地址值（16进制）
        堆内存中的数据都有默认值
3.方法区(Method Area):存储.class文件相关信息，包含方法信息
4.本地方法栈(Native Method Stack):与操作系统相关
5.寄存器(PC Register):与CPU相关

2.数组的内存图

一个数组的内存图

public class Array01 {
    public static void main(String[] args) {
        int[] array = new int[3];
        System.out.println(array);//地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//0
        System.out.println(array[2]);//0
        
        //对数组元素进行赋值
        array[1] = 10;
        array[2] = 20;
        System.out.println(array);//地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//10
        System.out.println(array[2]);//20
    }
}

代码执行流程图解及说明如下：

1. 所有程序的运行都会先找到main方法
2. 加载main方法到栈内存中，并为其开辟一块空间
3. 按照顺序结构，代码从上往下执行，开始定义数组
4. 定义数组使用了"new"关键字，转到堆内存中创建数组，并生成一个地址值
5. 打印数组名称，会由栈到堆，找到内存地址值，返回并打印内存地址值
6. 首先找到数组名称对应的地址值，并根据索引值找到元素位置
7. 将元素的默认值进行覆盖

3.两个数组使用同一内存地址

//复制Array01.java的代码粘贴两次
//将22行修改为int[] array01 = array;之后的代码将array修改为了array01
public class ArraySame {
    public static void main(String[] args) {
        int[] array = new int[3];
        System.out.println(array);//地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//0
        System.out.println(array[2]);//0
        System.out.println("======================");

        //对数组元素进行赋值
        array[1] = 10;
        array[2] = 20;
        System.out.println(array);//地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//10
        System.out.println(array[2]);//20
        System.out.println("======================");

		//将array[]赋值给新创建的array01
		int[] array01 = array;
        System.out.println(array01);//地址值
        System.out.println(array01[0]);//0
        System.out.println(array01[1]);//10
        System.out.println(array01[2]);//20
        System.out.println("======================");

        //对数组元素进行赋值
        array01[1] = 100;
        array01[2] = 200;
        System.out.println(array01);//地址值
        System.out.println(array01[0]);//0
        System.out.println(array01[1]);//100
        System.out.println(array01[2]);//200
    }
}

代码执行流程图解及说明如下：

1~7步和“一个数组的内存图解及说明相同，不再重复”
8. 将数组array赋值给了数组array01，array01得到了array的地址值
9. 依旧是先找到地址值，再根据索引值找到对应元素位置
10. 将对应元素的数据做出对应的修改

4.索引越界与空指针异常

索引越界

空指针异常

数组必须进行new初始化才能使用其中的元素
如果只是赋值了null没有使用new进行创建
那么将会发生空指针异常
【错误分析】
在打印元素时，会根据数组的地址值与索引值确定元素位置，由于没有使用new进行创建，堆内存中就没有对应的地址值，不能返回相应的数据，故而程序报错。

三、常用的数组操作

1.获取数组长度

格式

数组名称.length

代码实例：

int[] array01 = new int[3];
int l = array01.length;
System.out.println("数组的长度是："+l);//数组的长度是：3
int[] array02 = {1,2,3,4,5,6,7,8,9,10,11,12,13};
System.out.println("数组的长度是："+array02.length);//数组的长度是：13

//改变数组长度
int[] array03 = new int[3];
System.out.println(array03.length);
//再次使用new关键字，在堆内存中再次开辟一块内存空间
//因此array03[]对应的内存地址也随之改变
array03 = new int[5];
System.out.println(array03.length);

2.数组元素的遍历输出

遍历数组：将数组中的每一个元素打印出来

public class ArrayTraversal {
    public static void main(String[] args) {
        int[] array = {11,22,33,44,55};
		//使用for循环遍历
        for (int i = 0; i < array.length; i++) {
            System.out.println("这是第"+(i+1)+"个元素："+array[i]);
        }
    }
}

3.数组的最值

最大值

int[] array = {100,11,202,33,440,50}
int max = array[0];
for (int i = 1; i < array.length; i++) {
     if (max < array[i]) {
        max = array[i];
    }
}
System.out.println("最大值为："+max);

最小值

int[] array = {100,11,202,33,440,50}
int min = array[0];
for (int i = 1; i < array.length; i++) {
     if (min > array[i]) {
           min = array[i];
    }
}
System.out.println("最小值为："+min);

4.数组元素的反转

数组内反转

//定义数组
int[] array01 = {11,22,33,44,55};
//实现数组元素顺序反转
for (int a = 0,b = array01.length-1;a < b;a++,b--){
    int temp = 0;            
    temp = array01[a];       
    array01[a] = array01[b]; 
    array01[b] = temp;
}
for (int i = 0; i < array01.length; i++) {
    System.out.println(array01[i]);
}

借助其它数组反转

//定义数组
int[] array01 = {11,22,33,44,55};
//定义一个与array01相同长度的数组
int[] array02 = new int[array01.length];
//实现数组元素顺序反转
int n = 0 ;
for (int i = array01.length - 1; i >= 0; i--) {
System.out.println(n);
array02[n++] = array01[i];
}
//打印反转后的数组
for (int i = 0; i < array02.length; i++) {
System.out.println(array02[i]);
}

四、数组与方法

1.数组作为方法的参数

当调用方法时，向方法的小括号传递参数，这个参数实质为数组的地址值

public class ArrayParam {
    public static void main(String[] args) {
        //创建一个数组
        int[] array = {1,2,3,4};
        //调用方法，并将数组名称作为参数添加到方法的小括号
        printArray(array);
    }

    //定义一个数组作为参数的方法
    public static void printArray (int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

2.数组作为方法的返回值

方法产生了多个返回值的时候可用数组作为返回值

public class ArrayReturn {

    public static void main(String[] args) {
        //赋值调用方法
        int[] array = calculate(2,3,4);
        //打印返回值数组的数据
        System.out.println("和："+array[0]);
        System.out.println("平均值:"+array[1]);
    }

    //定义一个数组作为返回值的方法
    public static int[] calculate(int a, int b, int c){
        int sum = a + b + c;
        int avg = sum / 3;
        //将参数进行运算产生的两个结果存在数组中
        int[] array = {sum,avg};
        return array;
    }
}