JAVA基础篇——JAVA数组

四、JAVA数组

1. 简介

**概念：**一个存储一批同类型数据的容器

**作用：**简化大量变量的定义

2. 静态初始化数组、数组的访问

**概念：**定义的是时候直接赋值

格式：

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

简化：数据类型[] 数组名 = {元素1, 元素2, ……};

也可以写为：数据类型 数组名[]

public class ArrayDemo1 {
    public static void main(String[] args) {
        // 静态初始化数组
        int[] array1 = new int[] {1, 2, 3, 4};
        int array2[] = new int[4];
        int[] array3 = {2, 4, 6, 8};
        System.out.println(array1);
        System.out.println(array2);
        System.out.println(array3);
        
        // 问题：申请一定长度的数组——new后面指定
        // int array2[] = new int[4];
    }
}

计算机中的基本原理：

数组是一种引用数据类型——数组变量名中存储的是数组在内存中的地址

访问：

数组名[索引]、数组长度属性：数组名.length

应用——取值、赋值

3. 数组遍历

**概念：**一个一个访问数组

**原因：**求和、元素搜索、找最值

案例：

public class ArrayTest4 {
    public static void main(String[] args) {
        // 5名员工销售额：16、26、36、6、100，计算总销售额
        // 首先定义一个数组，遍历，求和
        int[] sale = {16, 26, 36, 6, 100};
        // 接收总销售额
        int sum = 0;
        for (int i = 0; i < sale.length; i++) {
            sum += sale[i];
        }
        System.out.println(sum);
    }
}

4. 动态初始化数组

**概念：**定义时不存入具体元素，只确定数组存储的数据类型和数组长度

格式：

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

后续再进行赋值

注意：静态初始化和动态初始化时独立的，不能混用——有数字不写花括号，有花括号不写数字

计算机中的基本原理：

使用的是堆内存，会赋默认的初始值

动态初始化数组元素默认值规则：——0、0.0、false、null

**适合场景：**只知道元素个数，不确定具体元素值

案例：

public class ArrayTest6 {
    public static void main(String[] args) {
        // 歌唱比赛录入6名评委的打分，录入完毕后立即输出平均分作为选手的得分
        // 首先定义一个长度为6的double数组，存放六位评委的打分
        // 赋值
        // 求和求平均
        double[] scores = new double[6];
//        scores[0] = 2;
//        scores[1] = 4;
//        scores[2] = 5;
//        scores[3] = 2;
//        scores[4] = 4;
//        scores[5] = 5;
        Scanner input = new Scanner(System.in);
        // sum记录总分
        double sum = 0;
        for (int i = 0; i < scores.length; i++) {
            scores[i] = input.nextDouble();
            sum += scores[i];
        }
        System.out.println(sum / 6);
    }
}

5. 数组的内存执行原理

运行一个JAVA程序，主要看JVM中的方法区、栈、堆

方法区：存放class文件

栈：main方法，变量的值，引用变量的地址

堆：new出来的对象

多个变量指向同一个数组的问题

修改一个数组的内容，调用另一个数组的内容也会发生相同的变化

6. 案例：求最值、翻转

求最值：

public class Demo1 {
    public static void main(String[] args) {
        // 求数组最大值
        int[] faceScores = {15, 9000, 10000, 20000, 9500, -5};
        // 定义一个变量存储最大值
        int max = faceScores[0];
        // 遍历数组，更新最大值
        for (int i = 1; i < faceScores.length; i++) {
/*            if (faceScores[i] > max) {
                max = faceScores[i];
            }*/
            // JAVA中的函数
            max = Math.max(max, faceScores[i]);

        }
        System.out.println(max);
    }
}

数组翻转：

public class Demo2 {
    public static void main(String[] args) {
        // 准备一个静态数组
        int[] arr = {10, 20, 30, 40, 50};
        // 双指针的思想
        int i = 0;
        int j = arr.length - 1;
        while (i < j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
        for (int i1 = 0; i1 < arr.length; i1++) {
            System.out.println(arr[i1]);
        }
    }
}

7. 随机排名

随机排名：

需求——依次录入5名员工的工号，然后展示出一组随机的排名顺序

思路——依次录入——>动态初始化数组

​ 遍历数组，产生索引的随机数——>交换位置进行打乱

public class Demo3 {
    public static void main(String[] args) {
        // 动态初始化长度为5的数组，因为工号整型可以存放，选用int
        int[] num = new int[5];
        // 输入工号
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < num.length; i++) {
            System.out.print("请输入工号：");
            num[i] = sc.nextInt();
        }
        // 遍历并打乱顺序
        Random rm = new Random();
        for (int i = 0; i < num.length; i++) {
            int index = rm.nextInt(num.length);
            int temp = num[i];
            num[i] = num[index];
            num[index] = temp;
        }
        // 打印
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }
    }
}

8. Debug工具使用

**概念：**断点调试工具，可以控制代码从断点开始一行一行的执行，看程序执行情况。

步骤：打断点——>右键debug——>控制代码一行一行执行

9. 总结