Java基础之案例

最新推荐文章于 2024-05-28 12:49:26 发布

屿风111

最新推荐文章于 2024-05-28 12:49:26 发布

阅读量1.2k

点赞数 4

文章标签： java 学习

本文链接：https://blog.csdn.net/qq_52670388/article/details/132428124

版权

案例1：买飞机票

用户购买机票时，机票原价会按照淡季、旺季，头等舱还是经济舱的情况进行相应的优惠，优惠方案如下：5-10月为旺季，头等舱9折，经济舱8.5折；11月到来年4月为淡季，头等舱7折，经济舱6.5折，请开发程序计算出用户当前机票的优惠价。

package case_exercise;

import com.sun.org.apache.xpath.internal.objects.XString;

public class Test1 {
    public static void main(String[] args) {
        //完成买飞机票的案例
       double a = calculate(4200,8,"头等舱");
        System.out.println("机票优惠后的价格为:" + a);
    }
    public static double calculate(double price, int month, String type){
        //1.判断当前月份为淡季还是旺季
        //旺季
        if (month >= 5 && month <= 10){
            //2.判断仓位类型
            switch (type){
                case "头等舱":
                    price *= 0.85;
                    break;
                case "经济舱":
                    price *= 0.9;
                    break;
            }
        }
        //淡季
        else{
            switch (type){
                case "头等舱":
                    price *= 0.7;
                    break;
                case "经济舱":
                    price *= 0.65;
                    break;
            }
        }
       return price;
    }
}

总结：

案例2：开发验证码

需求：

开发一个程序，可以生成指定位数的验证码，每位可以是数字、大小写字母。

package case_exercise;

import java.util.Random;

public class Test2 {
    public static void main(String[] args) {
        //完成生成随机验证码
        String code1 = createCode(6);
        System.out.println(code1);
    }
    public static String createCode(int n){
        //1.定义一个for循环用于控制产生多少位随机字符
        Random r = new Random();
        //3.定义一个String类型的变量用于记住产生的每位随机字符
        String code = " ";
        for (int i = 1; i <= n; i++) {
            //i = 1 2 3 4 5
            //2.为每个位置生成一个随机字符：可能是数字、大小写字母
            //思路:随机一个0，1，2之间的数字出来。0代表随机一个数字字符，1、2分别代表随机大写字母、小写字母
            int type = r.nextInt(3);  //0,1,2
            switch(type){
                case 0:
                    //随机一个数字字符
                    code += r.nextInt(10);  //0-9
                    break;
                case 1:
                    //随机生成一个大写字母
                    // A 65    Z 65+25  （0-25）+65
                    char ch1 = (char)(r.nextInt(26)+65);
                    code += ch1;
                    break;
                case 2:
                    //随机生成一个小写字母
                    // a 97    z 97+25   （0-25）+97
                    char ch2 = (char)(r.nextInt(26)+97);
                    code += ch2;
                    break;
            }
        }
        return code;
    }
}

总结：

案例3：评委打分

需求：

在唱歌比赛中，可能有多名评委要给选手打分，分数是[0-100]之间的整数。选手最后得分为：去掉最高分、最低分后剩余分数的平均分，请编写程序能够录入多名评委的分数，并算出选手的最终得分。

package case_exercise;

import java.lang.reflect.Array;
import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        //完成评委打分案例
        System.out.println("当前选手得分是:" + getAverageScore(6));
    }
    public static double getAverageScore(int n){
        //定义一个动态初始化数组,负责后期存入评委的打分
        int[] scores = new int[n] ;
        // scores = [0,0,0,0,0,0]

        Scanner sc = new Scanner(System.in);
        //遍历数组中的每个位置，依次录入评委的分数
        for (int i = 0; i < scores.length; i++) {
            System.out.println("输入第"+(i+1)+"个评委的打分:");
            int score = sc.nextInt();
            scores[i] = score;
        }
        double max = scores[0];  //保存最大值
        double min = scores[0];  //保存最小值
        double sum = 0;     //存总分数的变量
        for (int i = 0; i < scores.length; i++) {
            int score = scores[i];
            //求和
            sum += score;
            //求最大值
            if (score > max) {
                max = score;
            }
            //求最小值
            if (score < min){
                min = score;
            }
        }
        //计算平均分并返回
        double average = (sum - max - min) / (n - 2);
        return average;
    }
}

总结：

案例4：数字加密

需求：

某系统的数字密码是一个四位数，如1983，为了安全，需要加密后再传输，加密规则是：对密码中的每位数，都加5，再对10求余，最后将所有数字顺序反转，得到一串加密后的新数，请设计出满足本需求的加密程序！

package case_exercise;

public class Test4 {
    public static void main(String[] args) {
        //完成数字加密程序的开发
        System.out.println("加密后的结果是:"+encrypt(1983));
    }
    public static String encrypt(int number){

        //1.定义一个split方法将这个密码拆分成一个一个的数字,后续再对其进行加密
        int[] numbers = split(number);
        //numbers = [1,9,8,3]

        //2.遍历这个数组中的每个数字,对其进行加密处理
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = (numbers[i] + 5) % 10;
        }
        //numbers = [6,4,3,8]

        //3.对数组反转，把该操作交给一个独立的方法来完成
        reverse(numbers);
        //numbers = [8,3,4,6]

        //4.把加密后的数字拼接起来作为加密后的结果返回即可
        String data = "";
        for (int i = 0; i < numbers.length; i++) {
            data += numbers[i];
        }
        return data;
    }

    public static void reverse(int[] numbers) {
        //反转数组
        // numbers = [6,4,3,8]
        //            i     j
        for (int i = 0,j = numbers.length - 1; i < j; i++,j--) {
            //交换i、j位置处的数
            int temp = numbers[i];
            numbers[i] =numbers[j];
            numbers[j] = temp;
        }
    }

    public static int[] split(int number) {
        //将传入的密码拆分成一个一个的数字
        //number = 1983;
        int[] numbers = new int[4];
        numbers[0] = number / 1000;
        numbers[1] = (number / 100) % 10;
        numbers[2] = (number / 10) % 10;
        numbers[3] = number % 10;
        return numbers;
    }
}

总结：

案例5：数组拷贝

需求：

请把一个整型数组，例如存了数据：11，22，33，拷贝成一个一模一样的新数组出来。

package case_exercise;

public class Test5 {
    public static void main(String[] args) {
        //完成数组的拷贝
        int[] arr = {11,22,33};
        int[] arr2 = copy(arr);
        //写一个printArray方法将新数组打印出来
        printArray(arr2);
    }
    public  static  void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ",");
        }
        System.out.println("]");
    }
    public static int[] copy(int[] arr){
        //创建一个与原数组相同长度的新整型数组
        int[] arr2 = new int[arr.length];
        //将原数组中对应位置的元素通过遍历赋值给新数组
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[i];
        }
        return arr2;
    }
}

总结：

数组的拷贝是什么意思？

创建出一个与原数组一模一样的数组。

案例6：抢红包

需求：

一个大V直播时发起了抢红包活动，分别有：9、666、188、520、99999五个红包。请模拟粉丝来抽奖，按照先来先得，随机抽取，抽完即止，注意：一个红包只能被抽一次，先抽或后抽哪一个红包是随机的，示例如下（不一定是下面的顺序）：

方案一：

package case_exercise;

import java.util.Random;
import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        //完成抢红包案例
        int[] moneys = {9,666,188,520,9999};
        start(moneys);
    }
    public static void start(int[] moneys){
        // moneys = [9,666,188,520,9999]
        //           0  1   2   3    4
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        //1.定义一个for循环,控制抽奖5次
        for (int i = 0; i < moneys.length; i++) {
            //2.提示粉丝抽奖
            System.out.println("请您输入任意内容进行抽奖:");
            sc.next();   //等待用户输入内容，按下回车键才继续往下执行
            //3.为当前粉丝找出一个随机红包
            while (true) {
                int index = r.nextInt(moneys.length);
                int money = moneys[index];
                //4.判断这个红包是否不为0
                if (money != 0) {
                    System.out.println("恭喜您,您抽中了红包" + money + "元");
                    moneys[index] = 0;
                    break;  //结束这次抽奖
                }
            }
        }
        System.out.println("活动结束！！！");
    }
}

方案二：

package case_exercise;

import java.util.Random;
import java.util.Scanner;

public class Test6_1 {
    public static void main(String[] args) {
        //使用方法二完成抢红包案例
        int[] moneys = {9,666,188,520,9999};
        start(moneys);
    }
    public static void start(int[] moneys){
        // moneys = [9,666,188,520,9999]
        //           0  1   2   3    4

        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        //利用循环将传入的数组打乱顺序
        for (int i = 0; i < moneys.length; i++) {
            //生成随机数,随机下标元素与循环下标元素交换位置
            int j = r.nextInt(moneys.length);
            int temp = moneys[i];
            moneys[i] = moneys[j];
            moneys[j] = temp;
        }
        //将打乱后数组中的元素依次取出来
        for (int i = 0; i < moneys.length; i++) {
            System.out.println("请您输入任意内容进行抽奖:");
            sc.next();
            System.out.println("您抽中的金额为:"+moneys[i]);
        }
        System.out.println("活动结束！！！");
    }
}

总结：

案例7：找素数

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

说明：除了1和它本身以外，不能被其他正整数整除，就叫素数。

比如：3、7就是素数，而9、21等等不是素数。

方法一：

package case_exercise;

public class Test7 {
    public static void main(String[] args) {
        //完成找素数
        System.out.println("素数的个数为:"+search(101, 200)+"个");
    }
    public static int search(int start,int end){
        int count = 0;
        //start = 101    end = 200
        //1.定义一个for循环,找到101到200之间的每个数据
        for (int i = start; i <= end; i++) {

            //信号位思想
            boolean flag = true;  //假设的意思,默认认为当前i记住的数据为素数

            //2.判断当前i记住的这个数据是否是素数。
            for (int j = 2; j <= i/2; j++) {
                if (i % j == 0){
                    //说明i当前记住的这个数据不是素数
                    flag = false;
                    break;
                }
            }

            //3.根据判定的结果决定是否输出i当前记住的数据，是素数才输出展示
            if (flag){
                System.out.println(i);
                count++;
            }
        }
        return count;
    }
}

方法二:

package case_exercise;

public class Test7_1 {
    public static void main(String[] args) {
        //找素数
        int count = 0;
        //start = 101    end = 200
        //1.定义一个for循环,找到101到200之间的每个数据
        OUT:  //为外部循环指定标签
        for (int i = 101; i <= 200; i++) {

            //2.拦截判断该数是否为素数
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    //这个数不是素数,不能打印
                    continue OUT;
                }
            }
            count++;
            System.out.println(i);
        }
        System.out.println("个数为:" + count);
    }
}

方法三：

package case_exercise;

public class Test_2 {
    public static void main(String[] args) {
        for (int i = 101; i <= 200; i++) {
            //i = 101 102 103 ... 199 200
            // i遍历到的当前数据是否是素数，是则输出，不是则不输出
            if (check(i)){
                System.out.println(i);
            }
        }
    }

    public static boolean check(int data){
        for (int i = 2; i <= data / 2; i++) {
            if (data % i == 0){
                return false;  //不是素数
            }
        }
        return true;  //是素数
    }
}

总结：

案例8：打印九九乘法表

打印：

package case_exercise;

public class Test8 {
    public static void main(String[] args) {
        //打印九九乘法表
        //九行
        for (int i = 1; i <= 9; i++) {
            // i 1 2 3 4 5 6 7 8 9
            //第i行有j列
            for (int j = 1; j <= i; j++) {
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            System.out.println();
        }
    }
}

案例9：打印三角形

package case_exercise;

public class Test9 {
    public static void main(String[] args) {
        //打印三角形
        //1.先定义一个循环控制打印多少行
        int n = 4;
        for (int i = 1; i <= n; i++) {
            //2.控制打印多少个空格
            for (int j = 1; j <= (n - i); j++) {
                System.out.print(" ");
            }
            //3.控制打印多少个星星
            for (int j = 1; j <= (2*i-1); j++) {
                System.out.print("*");
            }
            //4.换行
            System.out.println();
        }
    }
}

package case_exercise;

public class Test9 {
    public static void main(String[] args) {
        //打印三角形
        //1.先定义一个循环控制打印多少行
        int n = 4;
        for (int i = 1; i <= n; i++) {
            //2.控制打印多少个空格
            for (int j = 1; j <= (n - i); j++) {
                System.out.print(" ");
            }
            //3.控制打印多少个星星
            for (int j = 1; j <= (2*i-1); j++) {
                System.out.print(j % 2 == 0 ? " " : "*");
            }
            //4.换行
            System.out.println();
        }
    }
}

案例10：模拟双色球

模拟双色球：用户投注一组号码

package case_exercise;

import java.util.Random;
import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        //目标:完成双色球系统的开发
       int[] userNumbers = userSelectNumbers();
       System.out.println("你投注的号码:");
       printArray(userNumbers);

       int[] luckNumbers = createLuckNumbers();
       System.out.println("你中奖的号码:");
       printArray(luckNumbers);

       judge(userNumbers,luckNumbers);
    }

    public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i <arr.length;i++) {
            System.out.print(i == arr.length -1 ? arr[i] : arr[i]+",");
        }
        System.out.println("]");
    }

    /**1.设计一个方法,用于让用户投注一组号码并返回(前6个是红球号码,最后1个是蓝球号码)*/
    public static int[] userSelectNumbers(){
        //2.创建一个整型数组,用于存储用户投注的7个号码（前六个是红球号码,最后一个是蓝球号码）
        int[] numbers = new int[7];
        //numbers = [0,0,0,0,0,0,0]
        //           0 1 2 3 4 5 6

        Scanner sc = new Scanner(System.in);

        //3.遍历前6个位置，让用户依次投注6个红球号码，存入
        for (int i = 0;i < numbers.length - 1;i++){
            //i = 0 1 2 3 4 5

            while (true) {
                //4.开始让用户为当前位置投注一个红球号码（1-33之间，不能重复）
                System.out.println("请您输入第"+(i+1)+"个红球的号码（1-33之间，不能重复）");
                int number = sc.nextInt();

                //5.先判断用户输入的红球号码是否在1-33之间
                if (number < 1 || number > 33){
                    System.out.println("对不起，您输入的红球号码不在1-33之间，请确认！");
                }else{
                    //号码在1-33之间,接着还要继续判断这个号码是否重复,不重复才可以使用
                    if (exist(numbers,number)){
                        //number当前这个红球号码是重复的
                        System.out.println("对不起，您当前输入的号码已经选择过，重复选择，请确认！");
                    }else{
                        //number记住的这个号码没有重复且在1-33之间，可以使用
                        numbers[i] = number;
                        break;   //结束当次投注，结束当前死循环
                    }
                }
            }
        }
        //6.投注最后一个蓝球号码
        while (true) {
            System.out.println("请您输入最后一个蓝球号码(1-16之间):");
            int number = sc.nextInt();
            if (number < 1 || number > 16){
                System.out.println("对不起，您输入的蓝球号码范围不正确");
            }else {
                numbers[6] = number;
                break;
            }
        }
        return numbers;
    }

    private static boolean exist(int[] numbers, int number) {

        //需求：判断number这个数字是否在numbers数组中存在
        //numbers = [12,25,18,0,0,0,0]
        //number  =  25
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == 0){
                break;
            }
            if(numbers[i] == number){
                return true;
            }
        }
        return false;
    }

    /**2.设计一个方法:随机一组中奖号码出来（6个红球号码,一个蓝球号码）*/
    public static int[] createLuckNumbers() {
        //1.创建一个整型数组,用于存储这7各号码
        int[] numbers = new int[7];

        Random r = new Random();
        //2.遍历前6个位置处，依次随机一个红球号码存入（1-33）,且不重复
        for (int i = 0; i < numbers.length - 1; i++) {

            //3.为当前这个位置随机一个红球号码来存入
            //1 - 33 ==> -1 ==> (0-32)+1
            while (true) {
                int number = r.nextInt(33) + 1;

                //4.判断这个号码是否之前出现过（红球号码不能重复）
                if (!exist(numbers, number)) {
                    //number不重复
                    numbers[i] = number;
                    break;   //结束死循环,代表找到了当前这个位置的一个不重复的红球号码
                }
            }
        }
        //3.录入一个蓝球号码(1-16)
        numbers[6] = r.nextInt(16)+1;
        return numbers;
    }

    /**3.设计一个方法,用于判断用户的中奖情况*/
    public static void judge(int[] userNumbers,int[] luckNumbers){

        //分别定义2个变量用于记住红球命中了几个以及蓝球命中了几个
        int redCount = 0;
        int blueCount = 0;

        //1.先判断红球命中的数量
        //遍历用户投注的号码前6个红球
        for (int i = 0; i < userNumbers.length - 1; i++) {
            //userNumbers[i]
            //开始遍历中奖号码的前6个红球号码,看用户当前选择的这个号码是否命中了
            for (int j = 0; j < luckNumbers.length - 1; j++) {
                if (userNumbers[i] == luckNumbers[j]){
                    redCount++;
                    break;
                }
            }
        }
        //2.判断蓝球是否命中
        blueCount = userNumbers[6] == luckNumbers[6] ? 1 :0;

        System.out.println("您命中的红球数量是:" + redCount);
        System.out.println("您命中的蓝球数量是:" + blueCount);

        //3.判断中奖详情,并输出结果
        if (redCount == 6 && blueCount == 1){
            System.out.println("恭喜您,获得最高1000万奖金");
        }else if (redCount == 6 && blueCount == 0){
            System.out.println("恭喜您,获得最高500万奖金");
        }else if (redCount == 5 && blueCount == 1){
            System.out.println("恭喜您,获得3000元奖金");
        }else if (redCount == 5 && blueCount == 0 || redCount == 4 && blueCount == 1){
            System.out.println("恭喜您,获得200元奖金");
        } else if (redCount == 4 && blueCount == 0 || redCount == 3 && blueCount == 1 || redCount == 3 && blueCount == 0 || redCount == 2 && blueCount == 1){
            System.out.println("恭喜您,获得10元奖金");
        } else if (redCount == 2 && blueCount == 1 || redCount == 1 && blueCount == 1 || redCount == 0 && blueCount == 1){
            System.out.println("恭喜您,获得5元奖金");
        } else {
            System.out.println("感谢您对福利事业做出的巨大贡献 ");
        }
    }
}