Java：数组案例：求最值、猜数字、随即排名、冒泡排序

案例：数组元素求最大值

分数分别为：15、9000、10000、20000、9500、-5

分析：

1. 把颜值数据拿到程序中去，用数组装起来。（都是已知的值，使用的是静态初始化数组）
2. 定义一个变量用于记录最大值，这个变量建议默认存储第一个元素值作为参照。
3. 遍历数组的元素，如果该元素大于变量存储的元素，则替换变量存储的值为该元素。
4. 循环结束后输出最大值变量即可。

实现代码如下：

public static void main(String[] args) {
    //需求：数组元素求最值
    //1.先定义一个静态初始化数组，存储一批分数
    int[] faceScore = {15,9000,10000,20000,9500,-5};
                        0   1    2     3     4   5
    //2.定义一个变量用于存储最大值元素，建议使用第一个元素作为参照。
    int max = faceScore[0];
    
    //3.遍历数组的每个元素，依次与最大值变量的数据比较，若较大，则替换。（此处快捷键faceScore.fori）
    for (int i = 1; i < faceScore.length; i++) {
        if (faceScore[i]>max){
            max = faceScore[i];
        }
    }
    //4.输出最大值变量存储数据即可
    System.out.println("数组的最大值是："+max);
}

案例：猜数字游戏

需求：

开发一个幸运小游戏，游戏规则如下：

游戏后台随机生成1-20之间的5个数（无所谓是否重复），然后让大家来猜数字：

• 未猜中提示：“未命中”，并继续猜测
• 猜中提示：“运气不错，猜中了”，并输出该数据第一次出现的位置，且输出全部5个数据，最终结束本游戏。

分析：

1. 随机生成5个1-20之间的数据存储起来----->使用数组（是动态初始化数组哦，因为我们并不知道数组的值是多少！）
2. 定义一个死循环，输入数据猜测，遍历数组，判断数据是否在数组中，如果在，进行对应提示并结束死循环；如果没有猜中，提示继续猜测直到猜中为止。

实现代码如下：

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("Wow~你猜中了该数据，猜中的数据索引是："+ i);
                break OUT;
            }
        }
        System.out.println("当前猜测的数据在数组中不存在，请重新猜测~");
    }
    //5.输出数组的全部元素，让用户看到自己确实是猜中了某个数据。
    for (int i = 0; i < data.length; i++) {
        System.out.print(data[i] + "\t");
    }
}

注意：在第4部中，单纯的break只能结束for循环。想要结束整个循环可以使用break OUT

案例：随机排名

需求：

需要5名人员进行汇报演讲，现在采用随机排名后进行汇报。

请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。

例如：22 33 35 13 88--------->13 35 88 33 22

分析：

1. 在程序中录入5名员工的工号存储起来------>使用数组（注意：我们要使用的是动态初始化的数组，用静态初始化数组就把东西写死啦！假如想要录入100个呢？所以要用动态的~）
2. 依次遍历数组中的每个元素，随机一个索引数据，让当前元素与该索引位置处的元素进行交换。
3. 遍历输出数组中的内容即可

演示代码如下：

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

        //2.定义一个循环，循环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.遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换
        //codes = [22, 33, 45, 13, 88]
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历的元素值：codes[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");
        }
    }

注意：注意代码中标红的部分，如何将元素进行交换是个问题。我们可以定义一个临时变量来存储。

例如：有三个瓶子A，B，C。A里面放着22，B里面放着35，C里面为空。那么如何将A和B的两个数据进行交换呢？

A：22         B：35         C：null   //初始状态

A：22         B：35         C：35   //把B赋给C

A：22         B：22         C：35   //把A赋给B

A：35         B：22         C：35   //把C赋给A

这样就完成了A和B数据的交换，记得要拿出一个“空瓶子”来临时存放哦~

案例：冒泡排序

冒泡排序的思想

• 每次从数组中找到最大值放在数组的后面去。
• 例如：
• 

 

实现冒泡排序的关键步骤分析

• 确定总共需要做几轮：数组的长度-1
• 每轮比较几次：
• 

实现的代码演示如下：

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

    //2.定义一个循环控制比较的次数
    for (int i = 0; i < arr.length; 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");
    }
}

冒泡排序的思想：

• 从头开始两两比较，把较大的元素与较小的元素进行交换
• 每轮把当前最大的一个元素存入到数组当前的末尾

冒泡排序的实现步骤：

• 定义一个外部循环控制总共需要冒几轮（数组的长度-1）
• 定义一个内部循环，控制每轮依次往后比较几个位置（数组长度-i-1）
• 如果当前位置的元素值>后一个位置的元素值，两者交换