Day05

一. 数组

1. 数组

   • 组就是指多个的意思 , 在之前我们的代码中使用的数据类型都是单个的 , 为了将多个相同类型的数据存储在一起 , 这时候就引出了组的概念
   • 数组是存储同一种数据类型多个元素的集合, 也可以看成是一个容器
   • 数组可以存储基本数据类型,也可以存储引用数据类型
   • 数组是java中的唯一底层容器

2. 数组的初始化

   • 就是为数组开辟连续的内存空间, 并为每个数组元素赋值

   • 静态初始化

     • 指定内容,数组的长度由jvm自动判断
     • 数据类型[] 数组名 = new 数据类型[ ]{元素,元素,元素,元素,元素}
     • 数据类型[] 数组名 = {元素,元素,元素,元素,元素}

   • 动态初始化

     • 指定数组的长度, 数组中的元素由jvm给出默认值
     • 数组类型[] 数组名 = new 数据类型[数组长度]

     public static void main(String[] args) {
        //静态初始化
        int[] arr = {5,6,7,2,1};
        
        //动态初始化
        int[] arr2 = new int[5];
     }
     

3. 注意事项

   • 数组的长度在创建的时候就固定了, 中途无法被改变
   • 数组是靠角标定位元素,角标值从0开始
   • 数组属于引用数据类型
   • 数组中元素必须是同一种数据类型

4. 数组的操作

   • 使用数组的角标对数组进行操作,我们可以将数组的一个角标位看作是一个变量
   • 获取数组的某个角标位 : arr[角标值]
     • 获取到数组中的某个角标之后, 就可以获取值和赋值了
   • 获取数组的长度(元素的个数) : arr.length

   public static void main(String[] args) {
    
    int[] arr = new int[5];
    //获取数组的0角标位
    int i = arr[0];
    //给数组的角标位赋值
    arr[0] = 4;
    
   }
   

5. 数组默认值

   • 整数型 : byte short int long 默认初始化值都是0
   • 浮点型 : float double 默认初始化值都是0.0
   • 布尔型 : boolean 默认初始化值是false
   • 字符型 : char 默认初始化值是 '\u0000' 十六进制的
   • 引用数据类型 : 所有引用数据类型的初始化值都是null

   public static void main(String[] args) {
    //整数型 默认值是0
    int[] is = new int[2];
    System.out.println(is[0]);
    //字符型 默认是值十六进制的 '\u0000'
    char[] chs = new char[2];
    System.out.println(chs[0]);
    //浮点型 默认值是0.0
    double[] ds = new double[2];
    System.out.println(ds[0]);
    //布尔型 默认值是false
    boolean[] bs = new boolean[2];
    System.out.println(bs[0]);
    //引用数据类型默认值是null
    String[] strs = new String[2];
    System.out.println(strs[0]);
    
   }
   

二. 内存图

1. java中内存分配
   • 栈 : 存储局部变量
   • 堆 : 存储new出来的数组或对象
   • 方法区 : 面向对象部分讲解
   • 本地方法区 : 和系统相关的方法
2. 数组动静态初始化步骤
   • 动态初始化
     • 开辟连续的内存空间
     • 分配角标
     • 赋上默认值
   • 静态初始化
     • 开辟连续的内存空间
     • 分配角标
     • 赋值指定的值
3. 多个变量引用同一个数组
   • 在栈中创建多个变量
   • 多个变量执行堆中的同一个数组对象

三. 数组常见的问题

1. ArrayIndexOutOfBoundsException

   • 数组角标越界异常
   • 访问了不存在的角标

2. NullPointerException

   • 空指针异常
   • 栈中的数组变量没有指向堆内存中的数组实体

3. 演示

   public static void main(String[] args) {
    
    int[] arr = new int[2];
    //会出现数组角标越界异常
    int i = arr[2];
    
    arr = null;
    //会出现空指针异常
    i = arr[0];
   }
   

四. 数组的基本操作

1. 遍历数组

   • 循环查看数组中每一个元素

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

2. 获取数组中的最大值

   • 遍历数组, 查找最大的值, 注意, 这个最大值一定是数组中的,所以我们不能随便给最大值变量赋一个默认值

     public static int getMax(int[] arr){
        //定义存储最大值的变量
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
     }
     

3. 反转数组

   • 将数组中的元素按照排列顺序反转, 例如角标0和最后一个角标位上的元素交换

     public static void reverse(int[] arr){
        //数组中的元素前后交换, 遍历的次数只能是数组长度的一半
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = temp;
        }
     }
     

4. 查找数组中某个值第一次出现的位置

   • 对比数组中每个元素,知道匹配成功,返回当前的角标,如果没有查找到, 返回一个负数

     public static int indexOf(int[] arr,int value){
        //数组中的元素前后交换, 遍历的次数只能是数组长度的一半
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==value) {
                return i;
            }
        }
        return -1;
     }
     

五. 二分查找

1. 定义

   • 使用折半的形式, 一次性剔除一半的无效元素, 提高了查找的效率
   • 使用二分查找的数组必须是有序的

2. 演示

   public static int binSearch(int[] arr, int value){
    //定义有效元素开始的角标
    int start = 0;
    //定义有效元素结束的角标
    int end = arr.length-1;
    //定义中间的比较值
    int mid ;
    //当有效范围的开始角标已经大于结束角标了,说明已经没有有效元素了
    while(start<=end){
        //计算中间的角标
        mid = (end+start)/2;
        if(arr[mid]==value){
            return mid;
        }else if(arr[mid]>value){
            //如果中间角标位上的值大于要查找的值,
            //说明中间值后面的数都不可能匹配上了
            end = mid - 1;
        }else if(arr[mid]<value){
            //如果中间角标位上的值小于要查找的值,
            //说明中间值前面的数都不可能匹配上了
            start = mid + 1;
        }
    }
    //没有找到的话返回-1
    return -1;
   }
   
   

六. 冒泡排序

1. 定义

   • 相邻的两个值比较, 然后交换位置, 每次循环都会将有效元素中最大的或最小的移动到有效位的最后
   • 经过多次循环之后,就可以派出一个有序的数组

2. 演示

   public static void bubbleSort(int[] arr){
    //外循环控制整体的循环次数,每次都可以确定一个最大或最小元素
    for (int i = 1; i < arr.length; i++) {
        //内循环控制有效范围内相邻元素的比较
        for (int j = 0; j < arr.length-i; j++) {
            if(arr[j]>arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
   }
   
   

总结:

1. 数组

   • 存放多个值得容器
   • 必须确定数据类型
   • 必须确定长度
   • 长度和数据类型都不能修改

2. 数组的创建

   • 静态初始化 : 先确定具体的数值, 由虚拟机来确定类型和长度
   • 动态初始化 : 先确定类型和长度, 里面是默认值

3. 数组的默认值

   • 整数: 0
   • 小数: 0.0
   • 字符: \u0000
   • 布尔: false
   • 引用数据类型: null

4. 数组的使用

   • 通过角标操作数组, 角标从 0开始, 到数组的长度 -1 结束
   • 获取元素 : arr[角标]
   • 设置元素 : arr[角标] = 值;

5. ​ 数组和循环的结合

   • 循环中的变量 i 设置为从0开始 到 arr.length-1结束

     for(int i = 0 ; i < arr.length ; i++){
         
     }
     
     

作业

1. 第一题

   • 键盘录入5个学生的年龄, 按照从大到小对年龄进行排序

2. 第二题

   • 键盘录入多个学生的年龄, 查找年龄为15的学生所在的位置

3. 扩展题

   • 查阅资料, 思考新的数组排序方法

4. 扩展题

   在歌唱比赛中,共有10位评委进行打分,在计算歌手得分时,去掉一个最高分,去掉一个最低分, 然后剩余的8位评委的分数进行平均,就是该选手的最终得分.输入每个评委的评分,求某选手的得分