【java】【基础5】使用java基础知识实战案例

最新推荐文章于 2024-06-26 15:09:51 发布

春天的菠菜

最新推荐文章于 2024-06-26 15:09:51 发布

阅读量1k

点赞数 3

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/legend818/article/details/131831356

版权

java 专栏收录该内容

83 篇文章 25 订阅

订阅专栏

前言：使用java学习的基础知识，进行案例实战

案例一：买飞机票

package com.runa.define2;

public class MethodDemo9 {
    public static void main(String[] args) {
       double price = calculate(1000,6,"头等舱");
        System.out.println("优惠价格是：" + price);
    }
    public static double calculate(double price, int month, String type){
        // 1 判断当前月份是否淡季还是旺季
        if(month >= 5 && month <= 10){
            //旺季
            //2 判断仓位类型
            switch (type){
                case "头等舱":
                    price *= 0.9;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
            }
        }else{
            //淡季
            //2 判断仓位类型
            switch (type){
                case "头等舱":
                    price *= 0.7;
                    break;
                case "经济舱":
                    price *= 0.65;
                    break;
            }
        }
        return price;
    }
}

案例二：开发验证码

package com.runa.define2;

import java.util.Random;

public class MethodDemo10 {
    public static void main(String[] args) {
        System.out.println("当前生成的验证码为：" + creatCode(4));
    }
    public static String creatCode(int n){
        // 1 定义一个for循环用于控制产生随机字符
        Random r = new Random();
        // 3 定义一个String类型的变量用于记住产生的每位随机字符
        String code = "";
        for (int i = 0; i < n; i++) {
            // 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:
                    // 随机一个大写字符 A65 Z 65+25
                    char ch1 = (char)(r.nextInt(26) + 65);
                    code += ch1;
                    break;
                case 2:
                    // 随机一个小写字符 a 97  z 97+25
                    char ch2 = (char)(r.nextInt(26) + 97);
                    code += ch2;
                    break;
            }
        }
        return code;
    }
}

案例三：评委打分

package com.runa.define2;

import java.util.Scanner;

public class MethodDemo11 {
    public static void main(String[] args) {
        System.out.println("当前选手得分是：" + getAveScore(6));
    }
    public static double getAveScore(int number){
        //1 定义一个动态初始化的数组，负责存储后期存储的分数
        int[] scores = new int[number];
        Scanner sc = new Scanner(System.in);
        // 2 遍历数组的每个位置，依次录入评委的分数
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请您录入第" + (i + 1) + "个评委的分数：");
            int sorce = sc.nextInt();
            scores[i] = sorce;

        }
        // 3 从数组当中计算出总分、最高分、最低分
        int sum = 0;
        int max = scores[0]; //最大值，使用数组的第一个数
        int min = scores[0];//最小值，使用数组的第一个数

        // 遍历数组找出符合条件数据
        for (int i = 0; i < scores.length; i++) {
            int score = scores[i];
            //求和
            sum += scores[i];
            // 求最大值
            if(scores[i] > max){
                max = scores[i];
            }
            // 求最小值
            if(scores[i] < min){
                min = scores[i];
            }
        }
        // 4 计算平均分返回

         return 1.0 * (sum - max - min)/(number-2);
    }
}

案例四：数字加密

package com.runa.define2;



public class MethodDemo12 {
    public static void main(String[] args) {
        System.out.println("加密后的结果是：" + ercrypt(1983));
    }
    public static String ercrypt(int number){
        // 1 把密码拆分成一个一个的数字，才可以对其进行加密
        int[] numbers = split(number);

        // 2 遍历这个数组中的每个数字，对其进行加密处理
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = (numbers[i] + 5) % 10;
        }
        // 3 对数组的数字进行反转，把对数组进行反转的操作交给一个独立的方法来完成
        reverse(numbers);
        // 4 把这些加密的数字拼接起来，作为加密后的结果返回
        String data = "";
        for (int i = 0; i < numbers.length; i++) {
            data += numbers[i];
            
        }
        return data;
    }

    public static void reverse(int[] numbers) {
        // 反转数组
        for (int i = 0,j = numbers.length - 1; i < j; i++, j--) {
            //  把后一位的值交给一个temp存储
            int temp = numbers[j];
            // 把前一个位置的值给后一位处
            numbers[j] = numbers[i];
            // 将temp赋值给前一个位置
            numbers[i] = 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;
    }
}

案例五：数组拷贝

package com.runa.define2;

public class MethodDemo13 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33};
        int[] arr2 = copy(arr);
        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){
        // arr = [11, 22, 33]
        //1 创建一个长度一样的整型数组
        int[] arr2 = new int[arr.length];
        // 2 把原数组的元素对应位置赋值给新数组
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[i];

        }
        //3 返回新数组
        return arr2;
    }
}

案例六：抢红包

6.1 方案1

会存在性能问题

package com.runa.define2;

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

public class MethodDemo14 {
    public static void main(String[] args) {
        int[] arr = {9, 66, 188, 520, 9999};
        start(arr);
    }
    public static void start(int[] moneys){
        // moneys = [9, 66, 188, 520, 99999]
        // 1 定义一个for循环，控制抽奖5次
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        for (int i = 1; i <= 5; i++) {
            // 2 提示粉丝抽奖
            System.out.println("请您输入【任意内容】进行抽奖");
            sc.next();//等待用户输入内容，按了回车才能往下走
            // 3 为当前的这个分数找一个随机的红包出来
            while (true) {
                int index = r.nextInt(moneys.length); // 0-4
                int money = moneys[index];

                // 4 判断这个红包是否不为0
                if(money != 0){
                    System.out.println("恭喜您，您抽中了红包：" + money);
                    moneys[index] = 0;
                    break;
                }
            }

        }
        System.out.println("活动结束！");
    }
}

6.2 方案2

略

案例七：找素数

7.1 方法1

package com.runa.define2;

public class MthodDemo15 {
    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;
    }
}

7.2 方法2

使用标签技术

package com.runa.define2;

public class MthodDemo15 {
    public static void main(String[] args) {
        search(101, 200);
    }

    public static void search(int start, int end) {
        int count = 0;
        //start = 101 end = 200
        // 1 定义一个 for循环找到101到200之间的每个数据
        OUT:
        for (int i = start; i <= end; 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);
    }

}

7.3 方法3

package com.runa.define2;

public class MthodDemo15 {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 101; i <= 200; i++) {
            if (check(i)) {
                System.out.println(i);
                count++;
            }
        }
        System.out.println("素数的总数为：" + count);
    }

    public static boolean check(int data) {

        for (int i = 2; i <= data / 2; i++) {
            if (data % i == 0) {

                return false;
            }
        }


        return true;
    }

}

案例八：打印乘法表

package com.runa.define2;

public class MehodDemo16 {
    public static void main(String[] args) {
        // 1 定义一个for循环打印多少行
        for (int i = 1; i <= 9 ; i++) {
            // 2 定义一个内部循环，控制打印多少列
            for (int j = 1; j <= i ; j++) {
                //
                System.out.print(j + "x" + i + "=" + j*i + "\t");

            }
            System.out.println();//换行
        }

    }

}

案例九：打印三角形

package com.runa.define2;

public class MethodDemo17 {
    public static void main(String[] args) {
        // 1 先定义一个循环打印多少行
        int n = 5;
        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.1 业务分析、用户投注一组号码

package com.runa.define2;

import java.util.Scanner;

public class MethodDemo18 {
    public static void main(String[] args) {
        int[] userNumbers = userSelectNumbers();
        printArray(userNumbers);


    }

    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个是红球，最后一个是篮球，并返回用户投注号码）
    public static int[] userSelectNumbers() {
        // 2 创建一个整型数组,用于存储用户投注的7个号码
        int[] numbers = new int[7];
        Scanner sc = new Scanner(System.in);
        //3 遍历前6个位置，存入
        for (int i = 0; i < numbers.length - 1; i++) {
            //i = 0 1 2 3 4 5
            // 4 开始让用户为当前位置投注一个红色号码(1-33)
            while (true) {
                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 {
                    // 继续判断号码是否重复了
                    if (exist(numbers, number)) {
                        // number当前号码重复了
                        System.out.println("对不起，请选择的号码重复了,请重新输入");
                    } else {
                        // number 可以使用
                        numbers[i] = number;
                        break;
                    }
                }
            }
        }
        //6 投注最后一个蓝色号码
        while (true) {
            System.out.println("请您输入最后一个蓝色号码（1-16）：");
            int number = sc.nextInt();
            // 判断用户输入的红球号码是否在1-16之间
            if (number < 1 || number > 16) {
                System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
            }else {
                // 蓝色球合法
                numbers[6] =number;
                break;
            }
        }
        return numbers;
    }

    public static boolean exist(int[] numbers, int number) {
        // 判断number数字是否在数组numbers中存在
        // numbers = [12,25,16,17,19,6]
        // number = 14

        for (int i = 0; i < numbers.length; i++) {
            // 优化，如果数组的元素是0就不找了
            if(numbers[i] == 0){
                break;
            }
            // 判断数组元素是否等于输入的number
            if(numbers[i] == number){
                return true;
            }

        }
        return false;

    }


}

10.2 随机生成一组中奖号码

package com.runa.define2;

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

public class MethodDemo18 {
    public static void main(String[] args) {
        int[] userNumbers = userSelectNumbers();
        printArray(userNumbers);
        int[] luckNumbers = createLuckNumbers();
        printArray(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个是红球，最后一个是篮球，并返回用户投注号码）
    public static int[] userSelectNumbers() {
        // 2 创建一个整型数组,用于存储用户投注的7个号码
        int[] numbers = new int[7];
        Scanner sc = new Scanner(System.in);
        //3 遍历前6个位置，存入
        for (int i = 0; i < numbers.length - 1; i++) {
            //i = 0 1 2 3 4 5
            // 4 开始让用户为当前位置投注一个红色号码(1-33)
            while (true) {
                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 {
                    // 继续判断号码是否重复了
                    if (exist(numbers, number)) {
                        // number当前号码重复了
                        System.out.println("对不起，请选择的号码重复了,请重新输入");
                    } else {
                        // number 可以使用
                        numbers[i] = number;
                        break;
                    }
                }
            }
        }
        //6 投注最后一个蓝色号码
        while (true) {
            System.out.println("请您输入最后一个蓝色号码（1-16）：");
            int number = sc.nextInt();
            // 判断用户输入的红球号码是否在1-16之间
            if (number < 1 || number > 16) {
                System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
            }else {
                // 蓝色球合法
                numbers[6] =number;
                break;
            }
        }
        return numbers;
    }

    public static boolean exist(int[] numbers, int number) {
        // 判断number数字是否在数组numbers中存在
        // numbers = [12,25,16,17,19,6]
        // number = 14

        for (int i = 0; i < numbers.length; i++) {
            // 优化，如果数组的元素是0就不找了
            if(numbers[i] == 0){
                break;
            }
            // 判断数组元素是否等于输入的number
            if(numbers[i] == number){
                return true;
            }

        }
        return false;

    }

    // 系统随机一组中奖号码（前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++) {
            //i = 0 1 2 3 4 5
            // 3 开始让用户为当前位置投注一个红色号码(1-33)
            while (true) {
                int number = r.nextInt(33) + 1;
                //4 判断number是否重复,这样是不重复才进去
                if(!exist(numbers,number)){
                    // number 正常可以使用
                    numbers[i] = number;
                    break;
                }
            }
        }
        // 5 录入一个人蓝球号码 1-16
        numbers[6] = r.nextInt(16) +1;
        return numbers;
    }


}

10.3 判断中奖情况

package com.runa.define2;

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

public class MethodDemo18 {
    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个是红球，最后一个是篮球，并返回用户投注号码）
    public static int[] userSelectNumbers() {
        // 2 创建一个整型数组,用于存储用户投注的7个号码
        int[] numbers = new int[7];
        Scanner sc = new Scanner(System.in);
        //3 遍历前6个位置，存入
        for (int i = 0; i < numbers.length - 1; i++) {
            //i = 0 1 2 3 4 5
            // 4 开始让用户为当前位置投注一个红色号码(1-33)
            while (true) {
                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 {
                    // 继续判断号码是否重复了
                    if (exist(numbers, number)) {
                        // number当前号码重复了
                        System.out.println("对不起，请选择的号码重复了,请重新输入");
                    } else {
                        // number 可以使用
                        numbers[i] = number;
                        break;
                    }
                }
            }
        }
        //6 投注最后一个蓝色号码
        while (true) {
            System.out.println("请您输入最后一个蓝色号码（1-16）：");
            int number = sc.nextInt();
            // 判断用户输入的红球号码是否在1-16之间
            if (number < 1 || number > 16) {
                System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
            }else {
                // 蓝色球合法
                numbers[6] =number;
                break;
            }
        }
        return numbers;
    }

    public static boolean exist(int[] numbers, int number) {
        // 判断number数字是否在数组numbers中存在
        // numbers = [12,25,16,17,19,6]
        // number = 14

        for (int i = 0; i < numbers.length; i++) {
            // 优化，如果数组的元素是0就不找了
            if(numbers[i] == 0){
                break;
            }
            // 判断数组元素是否等于输入的number
            if(numbers[i] == number){
                return true;
            }

        }
        return false;

    }

    // 系统随机一组中奖号码（前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++) {
            //i = 0 1 2 3 4 5
            // 3 开始让用户为当前位置投注一个红色号码(1-33)
            while (true) {
                int number = r.nextInt(33) + 1;
                //4 判断number是否重复,这样是不重复才进去
                if(!exist(numbers,number)){
                    // number 正常可以使用
                    numbers[i] = number;
                    break;
                }
            }
        }
        // 5 录入一个人蓝球号码 1-16
        numbers[6] = r.nextInt(16) +1;
        return numbers;
    }

    // 传入两组号码，判断是否中奖，并输出
    public static void judge(int[] userNumbers, int[] luckNumbers){
        //userNumbers = [2,3,12,23,25,33,8]
        //luckNumbers= [12,13,22,23,25,33,8]
        // 1 分别定义两个遍历用于记住红球命中几个，蓝球命中几个
        int redCount = 0;
        int blueCount = 0;
        // 2 先判断红球命中数量，遍历用户投注号码的前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;
                }
            }

        }
        // 3 判断蓝球是否命中了
        blueCount = userNumbers[6] == luckNumbers[6] ? 1 : 0;

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

        // 4 判断中奖详情，并输出结果
        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){
            System.out.println("恭喜你，中奖200元~~");
        }else if(redCount == 4 && blueCount ==0 || redCount == 3 && blueCount ==1){
            System.out.println("恭喜你，中奖10元~");
        }else if(redCount < 3 && blueCount ==1){
            System.out.println("恭喜你，中奖5元~");
        }else{
            System.out.println("感谢您对福利事业做贡献~~~");
        }
    }
}