【JavaSE】Java中的数组定义与使用

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

变量可以存储一个值
int a = 10;

     现在需要统计某班级全部学生的Java考试成绩，例如计算平均成绩、找到最高分等。

     假设该班级有80名学生，用前面所学的知识，程序首先需要声明80个变量来分别记住每位学生的Java考试成绩，然后在进行操作，这样做会显得很麻烦，而且错误率也会很高。因此我们可以使用容器进行操作。

     将所有的数据全部存储到一个容器中，统一操作。

一、什么是数组？

1.数组的特点

1.数组长度固定
2.只能存放同一种类型的数据

---

2.数组的好处

数组可以同时存放多个数据,我们可以统一操作

---

3.哪些地方能使用数组

使用数组保存多个学生的成绩
购物车
网站很多的商品

---

4.变量的格式

数据类型 变量名 = 初始值;
        int a = 10;

数组定义格式【记忆】
        第一种(常用)
            数据类型[] 数组名

       第二种(不常用)
            数据类型 数组名[]

例如：

public class Demo01 {
    public static void main(String[] args) {
        int[] arr1;
        double[] arr2;
        boolean[] arr3;
    }
}

---

二、数组的动态初始化

1.回顾变量的使用

回顾变量的使用:
    数据类型 变量名 = 初始值;
    int a = 10;
    a = 20; // 修改数据
    System.out.println(a); // 获取值

2.数组动态初始化

什么是动态初始化?
        创建数组时指定长度,内容由系统给默认值

数组动态初始化格式(重要):
        数据类型[] 数组名 = new 数据类型[长度];

动态初始化格式详解:
        数据类型: 数组要存放数据的类型
        []: 数组符号
        数组名: 就是变量名
        new: 新建/创建
        数据类型: 数组要存放数据的类型
        [长度]: 指定数组能够存放几个数据

---

3. 小结

什么是动态初始化?
        创建数组时指定长度,内容由系统给出默认值

动态初始化数组的格式:
        数据类型[] 数组名 = new 数据类型[长度];

例子：

public class Demo02 {
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[长度];
        // 定义一个数组,可以存放5个int类型的数据
        int[] arr1 = new int[5];

        // 定义一个数组,可以存放6个double类型的数据
        double[] arr2 = new double[6];
    }
}

---

三.数组的静态初始化

什么是静态初始化:
        在创建数组时,指定数组的内容

静态初始化格式:
        数据类型[] 数组名 = new 数据类型[] {数据1, 数据2, 数据3};

静态初始化简化格式:
        数据类型[] 数组名 = {数据1, 数据2, 数据3};

注意事项:
        在静态初始化时,千万不要即写数组长度,有指定具体的值
        new int[3] {11, 22, 33}; 画蛇添足,会报错

例子：

public class Demo08 {
    public static void main(String[] args) {
        // 定义一个数组,里面存储11, 22, 33这3个数据
        // 数据类型[] 数组名 = new 数据类型[] {数据1, 数据2, 数据3};
        //                索引   0   1   2
        int[] arr1 = new int[] {11, 22, 33};
        // 获取元素
        System.out.println(arr1[0]); // 11
        System.out.println(arr1[1]); // 22
        System.out.println(arr1[2]); // 33

        // 静态初始化简化格式
        // 数据类型[] 数组名 = {数据1, 数据2, 数据3};
        double[] arr2 = {3.3, 6.6, 8.8};
        System.out.println(arr2[0]); // 3.3
        System.out.println(arr2[1]); // 6.6
        System.out.println(arr2[2]); // 8.8
    }
}

---

四.数组的访问

1.索引的介绍

数组中会存放多个数据.如何来找到这些数据呢?
         数组会为每个数据搞一个编号,就是索引,从0开始编号的

数组中的一个数据就是一个元素

数组的访问(操作):
         获取元素: 数组名[索引]
         修改元素: 数组名[索引] = 新的值;

小结:
       数组的访问:
         获取元素:
         数组名[索引]

       修改元素:
         数组名[索引] = 新的值;

---

2.例子

public class Demo03 {
    public static void main(String[] args) {
        // 创建一个数组       索引   0  1  2
        int[] arr = new int[3]; // {0, 0, 0}

        System.out.println(arr); // [I@880ec60
        /* 了解即可
            [: 表示是一个数组
            I: 表示int类型的数组
            @: 没有实际含义,仅做分割使用
            880ec60: 数组的地址
         */
        // 获取数组中的元素, 数组名[索引]
        // 内容.sout  ctrl + d
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        // 修改元素: 数组名[索引] = 新的值;
        // 修改arr数组索引1的元素为20;
        arr[1] = 20;
        // 取出1索引的元素
        System.out.println(arr[1]); // 0 ? 20
    }
}

---

五.两个变量指向一个数组

int[] arr2 = arr1;
     =是赋值运算,将右边的值赋值给左边的变量
     右边的arr1保存的是数组的地址.将arr1数组的地址赋值arr2.
     arr1和arr2保存的是同一个数组

例子：

public class Demo07 {
    public static void main(String[] args) {
        // 新建一个数组
        int[] arr1 = new int[2];
        System.out.println(arr1); // 数组的内存地址
        System.out.println(arr1[0]); // 0
        System.out.println(arr1[1]); // 0

        // 注意: ?
        int[] arr2 = arr1;
        System.out.println(arr2); // 一样

        arr2[1] = 100;
        System.out.println(arr1[1]); // 100
        System.out.println(arr2[1]); // 100
    }
}

---

六.数组的常见问题

1.问题

1.数组索引越界异常
2.空指针异常

解决方法

1.数组索引越界异常,需要修改代码
2.空指针异常, 将数组设置为null,这个变量就没有保存任何地址.不能再操作

例子：

public class Demo09 {
    public static void main(String[] args) {
        // 1.数组索引越界异常
        //                      0   1   2
        int[] arr = new int[] {11, 22, 33};
//        System.out.println(arr[10]); // java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        // ArrayIndexOutOfBoundsException: 数组索引越界异常

        System.out.println(arr);
        // 2.空指针异常
//        arr = null;
        System.out.println(arr[0]);
    }
}

---

七.遍历数组

1.格式

数组的遍历格式:
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}

---

2.例子

public class Demo10 {
    public static void main(String[] args) {
        //            0   1   2   3
        int[] arr = {11, 22, 33, 44};
        /*
        System.out.println(arr[0]); // 11
        System.out.println(arr[1]); // 22
        System.out.println(arr[2]); // 33
        System.out.println(arr[3]); // 44*/
        // 以上代码是重复代码,只有索引在变化,可以使用循环
        /*for (int i = 0; i < 4; i++) { // i = 0,1,2,3
            System.out.println(arr[i]);
        }*/
        // 4就是元素的个数.数组有一个长度属性,得到数组的长度
        // 数组名.length: 得到数组的长度
        // 这个遍历的格式,必须掌握
        System.out.println("数组长度" + arr.length); // 数组长度4
        for (int i = 0; i < arr.length; i++) { // i = 0,1,2,3
            System.out.println(arr[i]);
        }

        // IDEA简洁操作: 数组名.fori
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        // IDEA 次数.fori: 快速生成for循环
        for (int i = 0; i < 100; i++) {

        }
    }
}

---

八.获取数组最大值

1.讲解

1.定义变量,保存比较后较大值,首先将索引0的元素赋值给这个变量
2.遍历数组获取每个元素
3.将获取的元素和变量比较
4.如果取出的数据大于变量的值,变量的值换成这个较大值
5.当遍历完成,最大值就出来啦

获取数组最大值思路
1.定义一个变量保存较大值
2.遍历得到后面的每个元素和变量去比较.保存较大值

---

代码示例

public class Demo12 {
    public static void main(String[] args) {
        //           0   1    2     3     4    5
        int[] arr = {5, 15, 2000, 10000, 100, 4000};
        // 1.定义变量,保存比较后较大值,首先将索引0的元素赋值给这个变量
        int max = arr[0];

        // 2.遍历数组获取每个元素
        for (int i = 1; i < arr.length; i++) {
            // 3.将获取的元素和变量比较
            // 4.如果取出的数据大于变量的值,变量的值换成这个较大值
            /*
                int i = 1       arr[1](15) > max(5)         true    max = 15;
                int i = 2       arr[2](2000) > max(15)      true    max = 2000;
                int i = 3       arr[3](10000) > max(2000)   true    max = 10000;
                int i = 4       arr[4](100) > max(10000)    false
                int i = 5       arr[5](4000) > max(10000)   false
             */
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        // 5.当遍历完成,最大值就出来啦
        System.out.println("最大值: " + max);
    }
}

---

九.拓展

1.求数组的和

题目：

假设有4个学生的考试成绩98, 66, 97, 68,总成绩

代码：

public class Demo13 {
    public static void main(String[] args) {
        // 1.定义数组保存学生的分数
        //                             0   1   2   3
        double[] arr = new double[] {98, 66, 97, 68}; // 长度是4

        // 2.求和思想, 定义一个变量保存总和
        int sum = 0;

        // 3.遍历数组,取出每个数据,加到总和里面
        for (int i = 0; i < arr.length; i++) { // i = 0, 1, 2, 3
            sum += arr[i]; // 98, 66, 97, 68
        }

        System.out.println("总和: " + sum); // 总和: 329
    }
}

---

2.统计数组中满足要求的数量

题目：

假设有5个学生的考试成绩98, 36, 97, 28, 59 统计不及格的人数

代码：

public class Demo14 {
    public static void main(String[] args) {
        // 1.使用数组保存所有学生的成绩
        //                      0   1   2   3   4
        int[] arr = new int[] {98, 36, 97, 28, 59}; // 数组长度5

        // 2.计数器思想 定义一个变量保存数量
        int count = 0;

        // 3.遍历数组,取出每个成绩
        for (int i = 0; i < arr.length; i++) { // i = 0, 1, 2, 3, 4, 5
            // 4.如果成绩小于60,不及格,数量+1
            //                      98      36      97      28     59
            if (arr[i] < 60) { // arr[0], arr[1], arr[2], arr[3], arr[4]
                count++; // 1, 2, 3
            }
        }

        // 5.打印不及格数量
        System.out.println("不及格的数量: " + count);
    }
}

---

3.数组元素反转

需求：
已知一个数组 arr = {11, 22, 33, 44, 55}; 用程序实现把数组中的元素值交换，
交换后的数组 arr = {55, 44, 33, 22, 11}; 并在控制台输出交换后的数组元素。

分析:
数组翻转思路,最远端交换
1.定义两个变量记录要换位置的小索引和大索引
2.小索引等于0
3.大索引等于数组最大索引
4.交换元素
5.小索引++,大索引–
6.交换元素
7.小索引++,大索引–
8.小索引小于大索引需要换元素(循环的条件)

代码：

public class Test09_2 {
    public static void main(String[] args) {
        int[] arr = new int[] {11, 22, 33, 44, 55};

        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }

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

---

4.交换数组的0索引和最后一个索引的元素

原数组: {11, 22, 33, 44, 55}

交换后: {55, 22, 33, 44, 11}

代码：

public class Demo051 {
    public static void main(String[] args) {
        // 1.定义一个数组
        int[] arr = new int[] {11, 22, 33, 44, 55};
        // int temp = arr[0]                    int temp = 11;
        // arr[0] = arr[arr.length - 1];        {55, 22, 33, 44, 55};
        // arr[arr.length - 1] = temp           {55, 22, 33, 44, 11};

        // 2.交换元素
        int temp = arr[0];
        arr[0] = arr[arr.length - 1];
        arr[arr.length - 1] = temp;

        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

---

5.评委打分题目

需求:
在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后得分为：去掉一个 最高分和一个最低分后的4个评委平均值 (不考虑小数部分)。

分析:
1.使用数组保存这6个分数 {99, 92, 97, 96, 95, 98}
2.得到最高分
3.得到最低分
4.得到总分
5.平均分 = (总分 - 最高分 - 最低分) / 人数

代码：

public class Test10_2 {
    public static void main(String[] args) {
        // 1.使用数组保存这6个分数 {99, 92, 97, 96, 95, 98} 2.得到最高分
        int[] arr = new int[] {99, 99, 99, 99, 95, 95};

        int max = arr[0];
        int min = arr[0];
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];

            if (max > arr[i]) {
                max = arr[i];
            } else if (min < arr[i]) {
                min = arr[i];
            }
        }

        // 5.平均分 = (总分 - 最高分 - 最低分) / 人数
        int avg = (sum - max - min) / (arr.length - 2);

        System.out.println("选手的平均分 = " + avg);
    }
}

---