清玉芳 - 文档中心

Appearance

day_07：综合练习 ​

案例一：卖飞机票 ​

需求：

  • 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱；
  • 按照如下规则计算机票价格:旺季(5-10月)头等舱9折，经济舱8.5折，淡季(11月到来年4月)头等舱7 折，经济舱6.5折。
java
static void main(String[] args) {
    //创建键盘录入对象
    Scanner sc = new Scanner(System.in);

    //键盘录入原价 月份 舱型
    System.out.println("请输入机票原价：");
    int priceOriginal = sc.nextInt();

    System.out.println("请输入月份：");
    int month = sc.nextInt();

    System.out.println("请输入舱型（头等舱/1  经济舱/2）：");
    int cabinType = sc.nextInt();

    //定义变量存储优惠价
    double priceSpecial = 0;

    if (cabinType == 1) {
        priceSpecial = getPrice(month, priceSpecial, priceOriginal, 0.9, 0.7);
    } else if (cabinType == 2) {
        priceSpecial = getPrice(month, priceSpecial, priceOriginal, 0.85, 0.65);
    } else {
        System.out.println("请输入正确的舱型！");
    }

    //输出结果
    System.out.println("优惠后价格未：" + priceSpecial);
}

//定义方法判断优惠后价格
public static double getPrice(int month, double priceSpecial, int priceOriginal, double x, double x1) {
    switch (month) {
        //旺季
        case 5, 6, 7, 8, 9, 10:
            priceSpecial = priceOriginal * x;
            break;
        //淡季
        case 11, 12, 1, 2, 3, 4:
            priceSpecial = priceOriginal * x1;
            break;
        default:
            System.out.println("请输入正确的月份！");
    }
    return priceSpecial;
}

案例二：找质数 ​

判断101-200之间有多少个素数，并输出所有素数。

java
static void main(String[] args) {
    //定义变量存储质数个数
    int count = 0;

    //循环判断
    for (int i = 101; i <= 200; i++) {
        if (getNumberPrime(i)) {
            System.out.println(i + "是质数");
            count++;
        }
    }

    //输出结果
    System.out.println("质数有：" + count + "个");

}

//定义方法求一个数是否未质数
public static boolean getNumberPrime(int num) {
    for (int i = 2; i < num; i++) {
        if (num % i == 0) {
            return false;
        }
    }
    return true;
}

案例三：开发验证码 ​

需求：

  • 定义方法实现随机产生一个5位的验证码
  • 验证码格式：
    • 长度为5
    • 前四位是大写字母或者小写字母:
    • 最后一位是数字
java
static void main(String[] args) {
    //定义字母数组
    char[] letterArr = new char[52];

    //定义数字数组
    int[] numberArr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    //定义变量存储验证码
    String result = "";

    //遍历数组
    for (int i = 0; i < letterArr.length; i++) {
        //添加小写字母与大写字母
        if (i <= 25) {
            letterArr[i] = (char) (97 + i);
        } else {
            letterArr[i] = (char) (39 + i);
        }
    }

    //获取前四位
    for (int i = 0; i < 4; i++) {
        result += letterArr[getRandomIndex(letterArr)];
    }

    //获取最后一位
    result += numberArr[getRandomIndex(numberArr)];

    //输出结果
    System.out.println(result);
}

public static int getRandomIndex(int[] arr) {
    //创建随机数对象
    Random r = new Random();

    //获取随机索引
    int randomIndex = r.nextInt(arr.length);

    //返回结果
    return randomIndex;
}

public static int getRandomIndex(char[] arr) {
    //创建随机数对象
    Random r = new Random();

    //获取随机索引
    int randomIndex = r.nextInt(arr.length);

    //返回结果
    return randomIndex;
}

案例四：数组元素的复制 ​

需求：

  • 把一个数组中的元素复制到另一个新数组中去。
java
//定义数组
int[] arr = {1,2,3,4,5,6};

//定义一个新的数组
int[] newArr = new int[arr.length];

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

//输出结果
for (int i = 0; i < newArr.length; i++) {
    System.out.println(newArr[i]);
}

案例五：评委打分 ​

需求： 在唱歌比赛中，有6名评委给选手打分，分数范围是[0-100]之间的整数。选手的最后得分为:去掉最 高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。

java
public class Test5 {
static void main(String[] args) {
    //调用方法获取分数数组
    int[] scoresArr = getScores();

    //调用方法获取数组和
    int sum = getSum(scoresArr);

    //调用方法获取数组最大值
    int max = getMax(scoresArr);

    //调用方法获取数组最小值
    int min = getMin(scoresArr);

    //去掉最大值与最小值并求结果
    double result = (sum - max - min) / (double) (scoresArr.length - 2);

    //输出结果
    System.out.println("最终得分为：" + result);
}

//定义方法获取分数数组
public static int[] getScores() {
    //定义数组存储分数
    int[] scoreArr = new int[6];

    //创建键盘录入对象
    Scanner sc = new Scanner(System.in);

    //遍历数组
    for (int i = 0; i < scoreArr.length; ) {
        System.out.println("请输入评委分数：");
        int score = sc.nextInt();
        if (score >= 0 && score <= 100) {
            scoreArr[i] = score;
            i++;
        } else {
            System.out.println("分数无效！");
        }
    }
    //返回分数数组
    return scoreArr;
}

//定义变量求数组和
public static int getSum(int[] arr) {
    //定义变量存储求和
    int sum = 0;

    //遍历数组
    for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
    //返回结果
    return sum;
}

//定义方法获取数组最大值
public static int getMax(int[] arr) {
    //定义变量存储最大值并以0索引1为初始值
    int max = arr[0];

    //遍历数组
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    //返回最大值
    return max;
}

//定义方法获取数组最小值
public static int getMin(int[] arr) {
    //定义变量存储最大值并以0索引1为初始值
    int min = arr[0];

    //遍历数组
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    //返回最大值
    return min;
}

案例六：数字加密 ​

需求：

  • 某系统的数字密码(大于0)，比如1983，采用加密方式进行传输。
  • 规则如下：先得到每位数，然后每位数都加上5，再对10求余，最后将所有数字反转，得到一串新数。
java
static void main(String[] args) {
    //创建键盘录入对象
    Scanner sc = new Scanner(System.in);

    //键盘录入一个整数
    System.out.println("请输入一个正整数：");
    int num = sc.nextInt();

    //调用方法进行加密
    int result = arrToNum(encryption3(encryption2(encryption1(numToArr(num)))));

    //输出结果
    System.out.println("加密结果为：" + result);
}

//定义函数将数字每一位添加到数组中
public static int[] numToArr(int num) {
    //定义变量记录位数
    int digit = 0;

    //定义变量原来获取每位数字
    int num2 = num;

    //循环获取数字位数
    while (num != 0) {
        num /= 10;
        digit++;
    }

    //定义数组存储每位数字
    int[] numArr = new int[digit];

    //定义数组索引
    int i = 1;

    //循环获取数字的每一位
    while (num2 != 0) {
        numArr[numArr.length - i] = num2 % 10;
        num2 /= 10;
        i++;
    }
    //返回结果
    return numArr;
}

//定义函数进行第一道加密
public static int[] encryption1(int[] arr) {
    //遍历数组并每位加5
    for (int i = 0; i < arr.length; i++) {
        arr[i] += 5;
    }
    //返回数组
    return arr;
}

//定义函数进行第二道加密
public static int[] encryption2(int[] arr) {
    //遍历数组并每位模10
    for (int i = 0; i < arr.length; i++) {
        arr[i] %= 10;
    }
    //返回数组
    return arr;
}

//定义函数进行第三道加密
public static int[] encryption3(int[] arr) {
    //遍历数组并反转
    for (int i = 0, j = arr.length - 1; i < j; ) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        i++;
        j--;
    }
    //返回数组
    return arr;
}

//定义函数将数组转换为数字
public static int arrToNum(int[] arr) {
    //定义变量存储结果
    int result = 0;

    //遍历数组
    for (int i = 0; i < arr.length; i++) {
        result = result * 10 + arr[i];
    }
    //返回结果
    return result;
}

案例七：数字解密 ​

将案例六加密后的数据解密出来。

java
static void main(String[] args) {

    //创建键盘录入对象
    Scanner sc = new Scanner(System.in);

    //键盘录入一个整数
    System.out.println("请输入一个正整数：");
    int num = sc.nextInt();

    //调用方法进行解密密
    int result = arrToNum(decrypt1(decrypt2(decrypt3(numToArr(num)))));

    //输出结果
    System.out.println("解密密结果为：" + result);
}

//定义函数将数字每一位添加到数组中
public static int[] numToArr(int num) {
    //定义变量记录位数
    int digit = 0;

    //定义变量原来获取每位数字
    int num2 = num;

    //循环获取数字位数
    while (num != 0) {
        num /= 10;
        digit++;
    }

    //定义数组存储每位数字
    int[] numArr = new int[digit];

    //定义数组索引
    int i = 1;

    //循环获取数字的每一位
    while (num2 != 0) {
        numArr[numArr.length - i] = num2 % 10;
        num2 /= 10;
        i++;
    }
    //返回结果
    return numArr;
}

//定义函数进行第三道解密
public static int[] decrypt3(int[] arr) {
    //遍历数组并反转
    for (int i = 0, j = arr.length - 1; i < j; ) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        i++;
        j--;
    }
    //返回数组
    return arr;
}

//定义函数进行第二道解密
public static int[] decrypt2(int[] arr) {
    //遍历数组并每位反模10
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] < 5) {
            arr[i] = arr[i] + 10;
        }
    }
    //返回数组
    return arr;
}

//定义函数进行第一道解密
public static int[] decrypt1(int[] arr) {
    //遍历数组并每位加5
    for (int i = 0; i < arr.length; i++) {
        arr[i] -= 5;
    }
    //返回数组
    return arr;
}


//定义函数将数组转换为数字
public static int arrToNum(int[] arr) {
    //定义变量存储结果
    int result = 0;

    //遍历数组
    for (int i = 0; i < arr.length; i++) {
        result = result * 10 + arr[i];
    }
    //返回结果
    return result;
}

案例八：模拟双色球[拓展] ​

image-20260805194436878

java
static void main(String[] args) {

    //获取中奖号码
    int[] winNumber = createWinNumber();

    //调用方法录入号码
    int[] guessNumber = createGuessNumber();

    //调用方法获取结果
    int redCount = checkRedCount(winNumber, guessNumber);
    boolean blueCoumt = checkBlueCount(winNumber, guessNumber);

    //输出获奖号码
    System.out.print("获奖号码为：");
    for (int i = 0; i < winNumber.length; i++) {
        System.out.print(winNumber[i] + " ");
    }

    //判断并输出结果
    switch (redCount) {
        case 0:
            if (blueCoumt){
                System.out.println("恭喜获得5元奖金！");
            }else {
                System.out.println("没有中奖！");
            }
            break;
        case 1,2:
            if (blueCoumt){
                System.out.println("恭喜获得5元奖金！");
            }else {
                System.out.println("没有中奖！");
            }
            break;
        case 3:
            if (blueCoumt){
                System.out.println("恭喜获得10元奖金！");
            }else {
                System.out.println("没有中奖！");
            }
            break;
        case 4:
            if (blueCoumt) {
                System.out.println("恭喜获得200元奖金！");
            } else {
                System.out.println("恭喜获得10元奖金！");
            }
            break;
        case 5:
            if (blueCoumt) {
                System.out.println("恭喜获得3000元奖金！");
            } else {
                System.out.println("恭喜获得200元奖金！");
            }
            break;
        case 6:
            if (blueCoumt) {
                System.out.println("恭喜获得1000万元奖金！");
            } else {
                System.out.println("恭喜获得500万元奖金！");
            }
            break;
        default:
            System.out.println("出错了！");
            break;
    }


}

//定义方法生成中奖号码
public static int[] createWinNumber() {
    //创建随机数对象
    Random r = new Random();

    //创建数组存储号码
    int[] winNumber = new int[7];

    //遍历数组并存储随机数
    for (int i = 0; i < winNumber.length; i++) {
        if (i == winNumber.length - 1) {
            //生成蓝球号码
            winNumber[i] = r.nextInt(1, 17);
        } else {
            //生成红球号码
            int num = r.nextInt(1, 34);

            //判断是否重复
            while (findNumber(winNumber, num)) {
                //重复则再次生成
                num = r.nextInt(1, 34);
            }

            //添加进入数组
            winNumber[i] = num;
        }
    }
    //返回结果
    return winNumber;
}

//定义方法录入号码
public static int[] createGuessNumber() {
    //定义数组存储购买的号码
    int[] guessNumber = new int[7];

    //创建键盘录入对象
    Scanner sc = new Scanner(System.in);

    for (int i = 1; i <= 7; i++) {
        //键盘录入号码
        System.out.println("请输入" + i + "号求的号码：");
        int num = sc.nextInt();

        if (i <= 6) {
            while (findNumber(guessNumber, num) || num < 1 || num > 33) {
                //再次键盘录入号码
                System.out.println("号码不合规，请重新输入" + i + "号求的号码：");
                num = sc.nextInt();
            }
        } else {
            while (num < 1 || num > 16) {
                //再次键盘录入号码
                System.out.println("号码不合规，请重新输入" + i + "号求的号码：");
                num = sc.nextInt();
            }
        }
        //将号码加入到数组中
        guessNumber[i - 1] = num;
    }
    return guessNumber;
}


//定义方法判断数组中是否存在该数字
public static boolean findNumber(int[] arr, int num) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == num) {
            return true;
        }
    }
    return false;
}

//定义方法判断红球相同的个数
public static int checkRedCount(int[] arr1, int[] arr2) {
    //定义变量记录相同元素个数
    int count = 0;

    for (int i = 0; i < arr1.length - 1; i++) {
        for (int j = 0; j < arr2.length - 1; j++) {
            if (arr1[i] == arr2[j]) {
                count++;
                //如果找到了，跳出内循环
                break;
            }
        }
    }
    return count;
}

//定义方法判断蓝球是否相同
public static boolean checkBlueCount(int[] arr1, int[] arr2) {
    if (arr1[arr1.length - 1] == arr2[arr2.length - 1]) {
        return true;
    } else {
        return false;
    }
}

案例九：二维数组 ​

  • 二维数组就是数组中存数组；
  • 当我们需要把数据分组管理的时候，就需要用到二维数组。

1. 二维数组的初始化 ​

静态初始化： ​

  • 格式：

    java
    数据类型[][] 数组名 = new 数据类型[][] {{元素1,元素2},(元素1，元素2);

  • 简化格式：

    java
    数据类型[][] 数组名 = {{元素1，元素2}，{元素1，元素2}};

动态初始化： ​

格式：

java
数据类型[][] 数组名 = new 数据类型[m][n];

m表示这个二维数组，可以存放多少个一维数组，n表示每一个一维数组，可以存放多少个元素。

2. 元素访问： ​

java
int 接收变量 = 数组名[索引][索引];

3. 遍历 ​

通过循环嵌套遍历二维数组。

java
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();
}

4. 特殊情况 ​

int[][] arr = new int[2][];
int[] arr1 = {11, 22};
int[] arr2 = {44, 55, 66};
arr[0] = arr1;
arr[1] = arr2;

某商城每个季度的营业额如下:单位(万元) 第一季度:22,66,44 第二季度:77,33,88 第三季度:25,45,65 第四季度:11,66,99 要求计算出每个季度的总营业额和全年的总营业额

java
static void main(String[] args) {
    //定义数组
    int[][] yearArrArr = {
            {22, 66, 44},
            {77, 33, 88},
            {25, 45, 65},
            {11, 66, 99}
    };

    //定义变量存储全年营业额
    int yesrSum = 0;

    //遍历二维数组获得一维数组调用方法求和
    for (int i = 0; i < yearArrArr.length; i++) {
        //定义变量存储每个季度营业额
        int quaryerSum = getQuarter(yearArrArr[i]);

        //输出每个季度营业额
        System.out.println("第" + (i + 1) + "季度营业额为：" + quaryerSum);

        //计算全年营业额
        yesrSum += quaryerSum;
    }
    //输出全年营业额
    System.out.println("全年营业额为：" + yesrSum);
}

//定义方法求每个季度营业额
public static int getQuarter(int[] arr) {
    //定义变量存储求和
    int sum = 0;

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

清玉芳 © 2026 All rights reserved.