Java 学习笔记（基础篇5）

1. 综合练习

(1) 抽奖

public class test10 {
    public static void main(String[] args) {
        int[] arr = {2,588,888,1000,10000};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int randomIndex = r.nextInt(arr.length);
            int temp = arr[randomIndex];
            arr[randomIndex] = arr[i];
            arr[i] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

关键逻辑：

循环变量i从 0 遍历到数组长度 - 1，对每个位置的元素进行随机交换操作，步骤如下：

• 生成随机索引：int randomIndex = r.nextInt(arr.length)，随机索引范围是 0 到数组长度 - 1（此例中为 0-4）。
• 交换元素：通过中间变量temp实现arr[i]和arr[randomIndex]的位置交换
• 由于代码仅进行元素位置的交换，没有新增、复制或删除元素，所以元素不会重复

(2) 双色球中奖系统

两大功能。具体需求如下：

号码组成：

• 红球：从 1-33 的整数中选择 6 个，不可重复
• 蓝球：从 1-16 的整数中选择 1 个，可与历史号码重复
• 一注完整号码包含 6 个红球 + 1 个蓝球，共 7 个数字

输入验证：

• 红球必须在 1-33 范围内，且 6 个红球不能重复
• 蓝球必须在 1-16 范围内
• 若用户输入不符合规则，需提示错误原因并要求重新输入

public class test11 {
    public static void main(String[] args) {
        int[] arr = createNumber();
        System.out.println("----------------");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        int[] userInputArr = userInputNumber();

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

        int redCount = 0;
        int blueCount = 0;

        for (int i = 0; i < userInputArr.length - 1; i++) {
            int redNumber = userInputArr[i];
            for (int j = 0; j < arr.length - 1; j++) {
                if (redNumber == arr[j]) {
                    redCount++;
                    break;
                }
            }
        }
        int blueNumber = userInputArr[userInputArr.length - 1];
        if (blueNumber == arr[arr.length - 1]) {
            blueCount++;
        }
        System.out.println();
        System.out.println(redCount);
        System.out.println(blueCount);
    }

    public static int[] userInputNumber(){
        int[] arr = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第" + (i + 1) + "个红球号码");
            int redNumber = sc.nextInt();
            if(redNumber >= 1 && redNumber <= 33){
                boolean flag = contains(arr, redNumber);
                if (!flag){
                    arr[i] = redNumber;
                    i++;
                } else{
                    System.out.println("当前红球号码已经存在，请重新输入");
                }
            } else{
                System.out.println("当前红球号码超出范围");
            }
        }
        System.out.println("请输入篮球号码");
        while (true) {
            int blueNumber = sc.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16){
                arr[arr.length - 1] = blueNumber;
                break;
            } else{
                System.out.println("当前蓝球号码超出范围");
            }
        }
        return arr;
    }

    public static int[] createNumber(){
        int[] arr = new int[7];
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            int redNumber = r.nextInt(33) + 1;
            boolean flag = contains(arr, redNumber);
            if (!flag) {
                arr[i] = redNumber;
                i++;
            }
        }
        int blueNumber = r.nextInt(16) + 1;
        arr[arr.length - 1] = blueNumber;
        return arr;
    }

    public static boolean contains(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }
}

① 蓝球输入的无限循环，蓝球输入使用while (true)循环，直到输入合法才break：

② contains() 方法：

public static boolean contains(int[] arr, int num) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == num) {  // 这里的num
            return true;
        }
    }
    return false;
}

• 括号里的num（int num）是形参：它是方法定义时声明的参数，用于接收调用方法时传入的实际值，是形参的 “定义处”。
• 代码里的num（arr[i] == num中的num）不是新的形参：它是对前面已经定义的形参num的 “使用”，引用的是同一个变量。

2. 二维数组

(1) 二维数组静态初始化：

int[][] arr = {{11, 22}, {33, 44}};

(2) 二维数组遍历

int[][] arr = {{11, 22, 33}, {44, 55, 66}};
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}

(3) 二维数组动态初始化

数据类型[][] 数组名 = new 数据类型[行数][列数];

示例：

int[][] arr = new int[2][3];  // 2行3列的二维数组
arr[0] = new int[]{11, 22, 33};
arr[1] = new int[]{44, 55, 66};

• 2：表示二维数组长度为 2，可以装 2 个一维数组
• 3：表示每一个一维数组的长度都是 3，可以装 3 个 Int 类型的元素

(4) 计算总营业额

public class test12 {
    public static void main(String[] args) {
        int[][] yearArrArr = {
                {22,66,44},
                {77,33,88},
                {25,45,65},
                {11,66,99}
        };

        int yearSum = 0;
        for (int i = 0; i < yearArrArr.length; i++) {
            int[] quarterArr = yearArrArr[i];
            int sum = getSum(quarterArr);
            System.out.println("第" + (i + 1) + "个季度的总营业额为" + sum);
            yearSum += sum;
        }
        System.out.println("全年总营业额为：" + yearSum);
    }

    public static int getSum(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}

这个程序中存在两次遍历，分别对应不同的层次：

① 第一次遍历（在main方法中）

遍历的是二维数组的外层，目的是逐个取出每个季度的一维数组：

// 外层循环：遍历二维数组，每次取出一个季度的一维数组
for (int i = 0; i < yearArrArr.length; i++) {
    int[] quarterArr = yearArrArr[i]; // 取出当前季度的一维数组
    // ...
}

② 第二次遍历（在getSum方法中）
遍历的是单个一维数组，目的是计算这个数组中所有元素的总和