数组与二维数组

数组介绍

数组是一种容器，可以存储同种数据类型的多个值

double[] arr1 = {11.1, 22.2, 33};
System.out.println(arr1[2]);		// 33.0

int[] arr2 = {10, 20, 'a'};			
System.out.println(arr2[2]);		// 97

数组的定义格式

数据类型[] 数组名;

int[] arr; 

数据类型 数组名[];

int arr[];

这种定义格式定义出来的只是数组类型的变量而已，此时容器还没有被真正的创建

数组的静态初始化

初始化：在内存中，为数组容器开辟空间，并将数组存入空间的过程
静态初始化完整格式：

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

int[] arr = new int[]{11,22,33,44,55};

静态初始化简化格式：

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

int[] arr = {11,22,33,44,55};

打印数组名将得到数组的十六进制内存地址

[I@233ac41

@ : 分隔符
[ : 代表当前空间是数组类型, 几个中括号就是几维数组
I : 当前数组是int类型
233ac41 : 十六进制内存地址

数组的元素访问

格式：数组名[索引];
索引介绍：(角标，下标)数组中，每一个空间所对应的编号，编号从0开始逐个+1增长

public static void main(String[] args) {

        int[] arr = {11, 22, 33, 44, 55};
        System.out.println(arr);        // 数组的地址值

        // 元素访问: 数组中的22元素取出来进行打印
        System.out.println(arr[1]);

        // 元素访问: 数组中33元素, 修改为66
        arr[2] = 66;
        System.out.println(arr[2]);

        // 元素访问: 判断数组中的第一个元素, 是奇数还是偶数
        if (arr[0] % 2 == 0) {
            System.out.println(arr[0] + "是一个偶数");
        } else {
            System.out.println(arr[0] + "是一个奇数");
        }
        // 元素访问: 根据数组中第二个元素, 决定在控制台打印多少次HelloWorld
        for(int i = 1; i <= arr[1]; i++){
            System.out.println("HelloWorld");
        }

    }

数组的遍历操作

介绍：将数组中的[每一个]元素取出进行操作
场景：如果要实现的需求需要操作到数组中的每一个数据，就需要遍历数组

 /*
        数组的遍历操作: 将数组中每一个元素, 取出来进行操作

        ----------------------------------------------

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);

        弊端: 代码的重复度太高, 过于臃肿
        解决: 使用循环解决

        ----------------------------------------------

        for(int i = 0; i < 5; i++){
            System.out.println(arr[i]);
        }

        弊端: 循环次数写死了(硬编码)
        解决: 每一个数组中, 都存在一个属性 length
                使用方式: 数组名.length ---> 动态的获取到数组的长度
                长度: 数组中的元素个数

        ----------------------------------------------


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

     */
    public static void main(String[] args) {

        int[] arr = {11, 22, 33, 44, 55};

        // 遍历数组快捷键: 数组名.fori + 回车
        for (int i = 0; i < arr.length; i++) {
            // i : 索引
            // arr[i] : 数组中的元素
            System.out.println(arr[i]);
        }

    }

需求: 已知数组元素为 {11,22,33,44,55}
1. 求出数组最大值
2. 求出数组最小值
3. 求出数组的总和
4. 计算数组的平均值
5. 将最大值, 最小值, 总和, 平均值打印在控制台

    public static void main(String[] args) {

        int[] arr = {11, 22, 33, 44, 55};

        // 1. 求出数组最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        // 2. 求出数组最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }

        // 3. 求出数组的总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        // 4. 计算数组的平均值
        double avg = sum / (arr.length * 1.0);

        // 5. 将最大值, 最小值, 总和, 平均值打印在控制台
        System.out.println("最大值为:" + max);
        System.out.println("最小值为:" + min);
        System.out.println("总和为:" + sum);
        System.out.println("平均值为:" + avg);
    }

数组的动态初始化

介绍：在创建数组的时候，只需要指定长度，系统就会分配默认初始化值
格式：数据类型[] 数组名 = new 数据类型[长度]；

int[] arr = new int[3];

默认值的分类：

整数 : 0
小数 : 0.0
布尔 : false
字符 : '\u0000'   ---> Unicode字符 ---> 常见的体现是空白字符
引用数据类型 : null
----------------------------------------

引用数据类型: 数组, 类, 接口

两种初始化的对比：

区别：
1. 动态初始化：手动指定长度，系统分配默认值
2. 静态初始化：手动指定元素，由系统计算出数组的长度

场景：
1.动态初始化：只知道要存储几个元素，但是明确具体数值
需求1：键盘录入5个整数，求出最大值
需求2：产生10个1~100之间的随机数，求出最小值

数组的内存图

Java内存分配介绍

数组的常见问题

数组索引越界异常：ArrayIndexOutOfBoundsException:
原因：访问了不存在的索引

空指针异常：NullPointerException:
原因：当引用数据类型的变量记录到null之后，代表跟堆内存的链接被切断了，这时候还要去访问堆内存的数据就会出现空指针异常

二维数组的介绍

介绍：二维数组也是一个容器，容器中存储的都是一维数组
场景：发现要操作的数组有多个，这多个数组也属于一个整体

某公司4个季度的销售额: 

int[][] arr = {
				{11,22,33},
				{11,55,22},
				{22,33,44},
				{77,11,33}
							}

二维数组静态初始化

完整格式：

数据类型[][] 数组名 = new 数据类型[][] {  
      {一维数组1},     
      {一维数组2}
};
int[][] arr = new int[][]{
      {11,22,33},
      {44,55,66}
};

简化格式：

数据类型[][] 数组名 = {
		{一维数组1},
		{一维数组2}
};

int[][] arr = {
	{11,22,33},
	{44,55,66}
};

二维数组的元素访问：

格式 : 数组名[m索引][n索引];

m索引 : 要访问哪一个一维数组
n索引 : 访问一维数组中的哪一个元素

System.out.println(arr[0][1]);

二维数组的遍历操作

思路：
遍历二维数组，获取到每一个一维数组
继续遍历一维数组，获得具体的元素

int[][] arr = {
	{11,22,33},
	{44,55,66}
};

// 遍历二维数组, 获取到每一个一维数组
for(int i = 0; i < arr.length; i++){
	// arr[i] : 代表每一个一维数组
	// 继续遍历一维数组, 获取具体的元素
	for(int j = 0; j < arr[i].length; j++){
		System.out.println(arr[i][j]);
	}
}

二维数组动态初始化

格式

数据类型[][] 数组名 = new 数据类型[m][n];

m : 指定这个二维数组, 可以存储多少个一维数组
n : 指定每一个一维数组中, 可以存储多少个元素

int[][] arr = new int[2][3];

这个二维数组, 可以存储2个一维数组, 每一个一维数组中可以存储3个元素

二维数组内存图