第一章_Java基础语法(6)_数组

一、数组的定义

• 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致
• 数组的定义格式
  • 数据类型[] 数组名（常用）：int[] arr;
  • 数据类型 数组名[]：int arr[];

二、数组的动态初始化

• 概念：在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值
• 动态初始化格式：数据类型[] 数组名 = new 数据类型[数组的长度];
• 注意：打印数组变量的时候, 会打印出数组的内存地址
  • [I@10f87f48：
    • @ : 分隔符
    • [ : 当前的空间是一个数组类型
    • I : 当前数组容器中所存储的数据类型
    • 10f87f48 : 十六进制内存地址

    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[数组的长度];
        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
        int[] arr = new int[5];
        // [I@10f87f48
        System.out.println(arr);

        byte[] bArr = new byte[3];
        // [B@b4c966a
        System.out.println(bArr);
    }

三、数组元素访问

• 数组的索引
  • 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始
  • 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素
  • 注意：数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值

    public static void main(String[] args) {
        int[] arr = new int[3];         // 0 1 2
        System.out.println(arr);        // 数组的内存地址  [I@10f87f48

        // 数组名[索引]  访问数组容器中的空间位置
        System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println("--------------");

        // 数组名[索引]
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }

• 数组默认值
  • 整数类型：0
  • 浮点数：0.0
  • 布尔：false
  • 字符：空字符
  • 引用数据类型：null

四、内存分配

• 内存概述
  • 内存是计算机中的重要原件，临时存储区域，作用是运行程序
  • 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的；必须放进内存中才能运行，运行完毕后会清空内存
  • Java虚拟机要运行程序，必须要对内存进行空间的分配和管理

区域名称	作用
寄存器	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

• 一个数组内存内存图

• 两个数组内存图

• 多个数组指向相同内存图

五、数组的静态初始化

• 什么是静态初始化
  • 在创建数组时，直接将元素确定
• 数组静态初始化的两种格式
  • 完整版格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
  • 简化版格式：数据类型[] 数组名 = {元素1,元素2,...};

    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
        int[] arr = new int[]{11,22,33};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        // 数据类型[] 数组名 = {数据1,数据2,数据3...};
        int[] arr2 = {44,55,66};
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }

• 动态初始化和静态初始化的区别
  • 动态初始化：手动指定数组长度，由系统给出默认初始化值
  • 静态初始化：手动指定数组元素，系统会根据元素个数计算出数组的长度

六、数组操作的常见问题

• 数组越界
  • 数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
  • 程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码

public class ArrayException {
    public static void main(String[] args) {
        int[] arr = new int[3]; // 0 1 2
        System.out.println(arr[3]);
    }
}

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

public class ArrayException {
    public static void main(String[] args) {
        // 空指针异常
        arr = null; // 空值
        System.out.println(arr[0]);
    }
}

七、数组遍历

• 数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现
• 获取数组元素数量：数组名.length

public class Test1Array {
    /*
        数组的遍历: 通过循环获取数组中的所有元素(数据)
        动态获取数组元素个数 : 数组名.length
     */
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55};
        // 数组名.length
        System.out.println("arr数组中元素的个数为:" + arr.length);
        //for(int i = 0; i < 5; i++){       手动写死了, 不严谨, 不推荐
        for(int i = 0; i < arr.length; i++){
            // i : 0 1 2 3 4
            System.out.println(arr[i]);
        }
    }
}

八、数组的案例应用

• 案例1：获取数组的中元素的最大值

public class Test2Array {
	//需求: 从数组中查找最大值；int[] arr = {12,45,98,73,60};
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};
        // 1. 假设数组中的第一个元素为最大值
        int max = arr[0];
        // 2. 遍历数组, 获取每一个元素, 准备进行比较
        for(int i = 1; i < arr.length; i++){
            // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //  4. 循环结束后, 打印最大值.
        System.out.println("max:" + max);
    }
}

• 案例2：数组元素求和

import java.util.Scanner;

public class Test3Array {
    /*
        需求：键盘录入5个整数，存储到数组中，并对数组求和
     */
    public static void main(String[] args) {
        // 1.创建键盘录入对象，准备键盘录入
        Scanner sc = new Scanner(System.in);
        // 2.定义一个求和变量，准备记录累加后的结果
        int sum = 0;
        // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
        int[] arr = new int[5];
        // 4.将键盘录入的数值存储到数组中
        for(int i = 0; i < arr.length; i++){
            System.out.println("请输入第" + (i+1) + "个整数:");
            //arr[i] = 10;
            arr[i] = sc.nextInt();
        }
        // 5.遍历数组，取出每一个元素，并求和
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        // 6.输出总和
        System.out.println("sum:" + sum);
    }
}

• 案例3：数组元素查找

import java.util.Scanner;

public class Test4Array {
    /*
        需求：
            已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。
     */
    public static void main(String[] args) {
        // 1.定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};
        // 2.键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的元素:");
        int num = sc.nextInt();
        // 3.定义一个索引变量，初始值为-1
        // 假设要查找的数据, 在数组中就是不存在的
        int index = -1;
        // 4.遍历数组，获取到数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            // 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
            if(num == arr[i]){
                // 如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
                index = i;
                break;
            }
        }
        //  6.输出索引变量
        System.out.println(index);
    }
}

• 案例4：评委打分

import java.util.Scanner;

public class Test5Array {
    /*
        需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
                选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
     */
    public static void main(String[] args) {
        // 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];
        // 2.键盘录入评委分数
        Scanner sc = new Scanner(System.in);
        //  3.由于是6个评委打分，所以，接收评委分数的操作，用循环
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i+1) + "个评委的打分:");
            int score = sc.nextInt();
            if(score >= 0 && score <= 100){
                // 合法的分值
                arr[i] = score;
            }else{
                // 非法的分值
                System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
                i--;
            }
        }
        // 4.求出数组最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }
        // 5.求出数组最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }
        // 6.求出数组总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        // 7.按照计算规则进行计算得到平均分
        int avg = (sum - max - min ) / 4;
        // 8.输出平均分
        System.out.println(avg);
    }
}