【Java】- 数组

1. 数组是什么

• 数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）
• 数组是属于引用数据类型
• 数组变量名中存储的是数组在内存中的地址信息

2. 数组如何定义

(1) 静态初始化数组

• 定义数组的时候直接给数组赋值
• 示例

public class ArrayDemo1 {
    public static void main(String[] args) {
        // 数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，...}
        // double[] scores = new double[]{99.5, 88.0, 75.5};
        double[] scores = {99.5, 88.0, 75.5};

        // int[] ages = new int[]{12, 24, 36};
        int[] ages = {12, 24, 36};

        // String[] names = new String[]{"牛二", "全蛋儿", "老王"};
        String[] names = {"牛二", "全蛋儿", "老王"};
    }
}

(2) 动态初始化数组

• 定义数组的时候只确定元素的类型和数组的长度，之后在存入具体数据
• 示例

public class ArrayDemo4 {
    public static void main(String[] args) {
    	// 定义一个动态初始化数组
        double[] scores = new double[3];
        // 赋值
        scores[0] = 99.5;
        
        System.out.println(scores[0]); // 99.5
        System.out.println(scores[2]); // 0.0


        String[] names = new String[90];
        names[0] = "迪丽热巴";
        names[2] = "马尔扎哈";
        System.out.println(names[0]); // 迪丽热巴
        System.out.println(names[1]); // null
        System.out.println(names[2]); //马尔扎哈     
    }
}

(3) 两种数组定义时的特点和场景有什么区别

• 当前已经知道存入的元素值，用静态初始化
• 当前还不清楚要存入哪些数据，用动态初始化

3. 数组如何访问

• 数组名称[索引]
• 示例

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] ages = {12, 24, 36};
        //            0    1    2
        // 取值：数组名称[索引]
        System.out.println(ages[0]);
        System.out.println(ages[1]);
        System.out.println(ages[2]);

        // 赋值：数组名称[索引] = 数据;
        ages[2] = 100;
        System.out.println(ages[2]);

        // 访问数组的长度
        System.out.println(ages.length);
    }
}

4. 数组的注意事项

• “数据类型[] 数组名” 也可以写成 “数据类型 数组名[]”
• 什么类型的数组存放什么类型的数据我，否则报错
• 数组一旦定义出来，程序执行的过程中，长度、类型就固定了

5. 数组元素默认值规则

数据类型	明细	默认值
	byte、short、char、int、long	0
基本类型	float、double	0.0
	boolean	false
引用类型	类、接口、数组、String	null

6. 数组遍历介绍

• 遍历：就是一个一个数据的访问
• 搜索、数据统计等等都需要用到遍历
• 示例

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = {12, 24, 12, 48, 98};

        // 原始遍历方式
//        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]);
        }
        
        // 快捷键 arr.fori
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

7. 数组的案例

• 案例1：数组元素求和

public class Test1 {
    public static void main(String[] args) {
        // 1、吧这些数据拿到程序中使用数组记住
        int[] money = {16, 32, 8, 100, 78};

        // 3、定义一个求和变量累加数组的元素值
        int sum = 0;

        // 2、遍历数组中的每个元素
        for (int i = 0; i < money.length; i++) {
            // 拿到每个元素值累加
            sum += money[i];
        }
        
        // 4、输出求和变量即可
        System.out.println("数组的元素和是：" + sum);
    }
}

• 案例2：数组元素求最大值

public class Test2 {
    public static void main(String[] args) {
        // 1、定义一个静态初始化的数组，存储一批颜值
        int[] faceScore = {15, 9000, 10000, 20000, 9500, -5};

        // 2、定义一个变量用于存储最大值元素，建议使用第一个元素作为参照
        int max = faceScore[0];

        // 3、遍历数组的每个元素，一次与最大值变量的数据比较，若较大，则替换
        for (int i = 0; i < faceScore.length; i++) {
            if (faceScore[i] > max) {
                max = faceScore[i];
            }
        }

        // 4、输出最大值变量存储的数据
        System.out.println("数组的最大值是：" + max);
    }
}

• 案例3：猜数字游戏

public class Test3 {
    public static void main(String[] args) {
        // 需求：5个1-20之间的随机数，让用户猜测，猜中要提示猜中，还要输出该数据在数组中第一次出现的索引，并打印数组的内容出来
        // 没有猜中继续

        // 1、定义一个动态初始化的数组存储5个随机的1-20 之间的数据
        int[] data = new int[5];

        // 2、动态的生成5个1-20之间的随机数并存入到叔祖父中去
        Random r = new Random();
        for (int i = 0; i < data.length; i++) {
            data[i] = r.nextInt(20) + 1;
        }

        // 3、使用一个死循环让用户进行猜测
        Scanner sc = new Scanner(System.in);
        OUT:
        while (true) {
            System.out.println("请您输入一个1-20之间的整数进行猜测：");
            int guessData = sc.nextInt();

            // 4、遍历数组中的每个数据，看是否有数据与猜测的数据相同，相同代表猜中了，给出提示
            for (int i = 0; i < data.length; i++) {
                if (data[i] == guessData) {
                    System.out.println("您已经猜中了该数据，运气不错了！您猜中的数据索引是：" + i);
                    break OUT; // 结束了整个死循环，代表游戏结束了！
                }
            }
            System.out.println("当前猜测的数据在数组中不存在，请重新猜测！");
        }

        // 5、输出数组的全部元素，让用户看到自己确实是猜中了某个数据
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }
    }
}

• 案例4：随机排名

public class Test4 {
    public static void main(String[] args) {
        // 目标：键盘录入一组工号，最终要随机输出一组出来作为排名
        // 1、动态初始化一个数组，存储5个工号
        int[] codes = new int[5];

        // 5、定义一个循环，循环5次，依次录入一个工号存入对应的位置
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            // 正式录入工号
            System.out.println("请输入第" + (i + 1) + "个员工的工号：");
            int code = sc.nextInt();
            // 存入到数组中去
            codes[i] = code;
        }

        // 3、遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            // 当前遍历的元素值：code[i]
            // 随机一个索引位置出来：codes[index]
            int index = r.nextInt(codes.length);

            // 定义一个临时变量存储index位置处的值
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }

        // 4、遍历数组元素输出就是随机排名的结果
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i] + "\t");
        }
    }
}

• 案例5：冒泡排序

public class Test5 {
    public static void main(String[] args) {
        // 1、定义一个数组，存储一些数据
        int[] arr = {5, 2, 3, 1};

        // 2、定义一个循环控制比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // i == 0 比较的次数 3   j = 0 1 2
            // i == 1 比较的次数 2   j = 0 1
            // i == 2 比较的次数 1   j = 0
            // 3、定义一个循环控制每轮比较的次数，占位
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 判断j当前位置的元素值 是否 大于后一个位置 若较大 则交换
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }

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

8. 数组常见问题

• 如果访问的元素位置超过最大索引，执行时会出现ArrayIndexOutOfBoundsException(数组索引越界异常)
• 如果数组变量中没有存储数组的地址，而是null，在访问数组信息时会出现NullPointerException(空指针异常)