Java基础语法（五)之数组

数组

数组的概念：是一种容器，可以同时存放多个数据值。

数组的特点：

1. 数组是一种引用数据类型
2. 数组当中的多个数据，类型必须统一
3. 数组的长度在程序运行期间不可改变

数组的初始化

在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：

1. 动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。
2. 静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

1 动态初始化数组

格式：

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

解析含义：
左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号：代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

// 创建一个数组，里面可以存放300个int数据
        // 格式：数据类型[] 数组名称 = new 数据类型[数组长度];
        int[] arrayA = new int[300];

2静态初始化

基本格式：

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

// 直接创建一个数组，里面装的全都是int数字，具体为：5、15、25
        int[] arrayA = new int[] { 5, 15, 25, 40 };

注意事项：
虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

3省略的静态初始化

标准格式：

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

省略格式：

数据类型[] 数组名称 = { 元素1, 元素2, … };
// 省略格式的静态初始化
int[] arrayA = { 10, 20, 30 };

注意事项：

1. 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
2. 静态初始化标准格式可以拆分成为两个步骤，先定义数组名称，再将new的值赋值。
   int[] arrayB;
   arrayB = new int[] { 11, 21, 31 };
3. 动态初始化也可以拆分成为两个步骤。
   int[] arrayC;
   arrayC = new int[5];
4. 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。
   错误写法
   int[] arrayD;
   arrayD = { 10, 20, 30 };

访问数组元素进行获取

直接打印数组名称，得到的是数组对应的：内存地址哈希值。
访问数组元素的格式：数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号。
【注意】索引值从0开始，一直到“数组的长度-1”为止。

数组的默认值

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为’\u0000’；
如果是布尔类型，那么默认为false；
如果是引用类型，那么默认为null。

注意事项：
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

Java中的内存划分

Java的内存需要划分为五个部分，
1栈（Stack):存放的都是方法的局部变量，方法的运行一定要在栈当中
局部变量：方法的参数，或者是方法{}内部的变量
作用域：一旦超出作用域，立刻从栈内存消失
2堆(Heap) 凡是new 出来的东西，都在堆当中
堆内存里面的东西都有一个地址值
堆内存里面的数据，都有默认值
规则如上
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为’\u0000’；
如果是布尔类型，那么默认为false；
如果是引用类型，那么默认为null。
3方法区（method area）存储.class相关信息，包含方法的信息。
4 本地方法栈(Native Method Stack):与操作系统相关
5 寄存器(pc Register):与cpu相关

一个数组的内存图

1main的头放在方法区（方法的信息）
2方法区的信息加载到栈内存中，为main方法在栈内存中开辟空间，main方法进栈
3创建数组，数组名称就是局部变量 int[] array 在栈中创建变量
4凡是new出来的东西都在堆内存，new int[3];,在堆内存中开辟一段内存空间，长度为3，就将他划分为三个小格，数组创建出来都有默认值，因为是整数类型，所以默认值都是0
堆当中的创建出来的数组是有地址值的，0x666(十六进制)
5数组的地址值被赋值到栈里的array名称中
6返回栈内存继续执行方法，输出array即为地址值
array[0], 根据数组名称找到数组地址，再根据相应编号找到数组元素，array[1], array[2]同理
array[1],array[2]根据数组名称找到数组地址，再根据相应编号找到数组元素,再重新赋值

两个数组内存图

两个数组互不联系

两个引用指向一个数组内存图

int[] arrayB =arrayA 将A数组的地址值赋给B数组，操作同一个数组
B数组的赋值修改数组中的值

数组索引越界异常

数组的索引编号从0开始，一直到“数组的长度-1”为止。
如果访问数组元素的时候，索引编号并不存在，那么将会发生
数组索引越界异常
ArrayIndexOutOfBoundsException
原因：索引编号写错了。
解决：修改成为存在的正确索引编号。

数组空指针异常

所有的引用类型变量，都可以赋值为一个null值。但是代表其中什么都没有。
数组必须进行new初始化才能使用其中的元素。
如果只是赋值了一个null，没有进行new创建。
那么将会发生：
空指针异常 NullPointerException

原因：忘了new

int[] array = null; //        array = new int[3];
       System.out.println(array[0]);  发生空指针异常，补上new即可 解决：补上new

数组的长度

如何获取数组的长度

格式：

数组名称.length
这将会得到一个int数字，代表数组的长度。
数组一旦创建，程序运行期间，长度不可改变。

数组的遍历输出

快捷键 array.fori
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}

数组元素的反转：

本来的样子：[1, 2, 3, 4]
之后的样子：[4, 3, 2, 1]
要求不能使用新数组，就用原来的唯一一个数组。

分析

1. 数组元素的反转，其实就是对称位置元素的交换
2. 遍历数组是一个索引，对称位置需要两个索引 int min =0 int max =array.length -1
3. 如何交换两个变量的值 借助中间变量 int temp =a a =b b=temp
4. 什么时候停止交换 当两个索引 min ==max 数组为奇数个元素时 min> max 数组为偶数个元素时，两个索引刚好错过
5. 什么时候应该交换 min<max

/*
        初始化语句：int min = 0, max = array.length - 1
        条件判断：min < max
        步进表达式：min++, max--
        循环体：用第三个变量倒手
         */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

数组作为方法的参数传递地址

数组可以作为方法的参数，当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。

public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };
        printArray(array);
    }
 /*
    三要素
    返回值类型：只是进行打印而已，不需要进行计算，也没有结果，用void
    方法名称：printArray
    参数列表：必须给我数组，我才能打印其中的元素。int[] array
     */
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

数组作为方法的返回值，返回地址

一个方法可以有0、1、多个参数；但是只能有0或者1个返回值，不能有多个返回值。
如果希望一个方法当中产生了多个结果数据进行返回，怎么办？
解决方案：使用一个数组作为返回值类型即可。

任何数据类型都能作为方法的参数类型，或者返回值类型。

数组作为方法的参数，传递进去的其实是数组的地址值。
数组作为方法的返回值，返回的其实也是数组的地址值。

public static void main(String[] args) {
        int[] result = calculate(10, 20, 30);
        System.out.println("总和：" + result[0]);
        System.out.println("平均数：" + result[1]);
    }
  public static int[] calculate(int a, int b, int c) {
        int sum = a + b + c; // 总和
        int avg = sum / 3; // 平均数
        // 两个结果都希望进行返回

        // 需要一个数组，也就是一个塑料兜，数组可以保存多个结果
        /*
        int[] array = new int[2];
        array[0] = sum; // 总和
        array[1] = avg; // 平均数
        */

        int[] array = { sum, avg };
        return array;
    }

方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.