基础Java编程练习

第一题：完成买飞机票的价格计算

import java.util.Scanner;

public class Test01 {
    public static void main(String[] args) {
        //目标：完成买飞机票的价格计算
//        1. 让用户输入机票原价，月份，仓位类型
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入机票原价：");
        double money = sc.nextDouble();


        System.out.println("请您输入机票的月份（1-12）：");
        int month = sc.nextInt();

        System.out.println("请您选择舱位类型（头等舱/公务舱/经济仓）：");
        String Class = sc.next();// 创建变量类型Ctrl+alt+v键
        System.out.println(calc(money, month, Class));
//        System.out.println();
    }

    //    定义方法计算机票价格
    public static double calc(double money,int month, String Class) {
        // 3.判断用户输入的信息
        if (month >= 5 && month <= 10) {
//            旺季
            switch (Class) {
                case "头等舱":
                    money *= 0.9;
                    break;
                case "公务舱":
                    money *= 0.95;
                    break;
                case "经济舱":
                    money *= 0.85;
                    break;
                default:
                    System.out.println("您输入舱位类型有误!请重新输入~~");
                    money = -1;
            }
        } else if (month == 11 || month == 12 || month >= 1 && month <= 4) {

//            淡季
            switch (Class) {
                case "头等舱":
                    money *= 0.7;
                    break;
                case "公务舱":
                    money *= 0.75;
                    break;
                case "经济舱":
                    money *= 0.65;
                    break;
                default:
                    System.out.println("您输入舱位类型有误!请重新输入~~");
                    money = -1;

            }
        } else {
            System.out.println("您输入月份有误!请重新输入");
            return -1;
        }
        return money;

    }
}

第二题：找素数

需求：判断101~200之间有多少个素数，并输出所有素数。

素数：如果除了1和它本身之外，不能被其他正整数整除。

public class Test2 {
    public static void main(String[] args) {
        /*判断101~200之间有多少个素数，并输出所有素数*/
//        1.定义一个循环,找到101~200之间的全部素数
        for (int i = 101; i <=200; i++) {
//            101 102 103 199 200
//        标记信号位
            boolean flag = true;
//            一开始认为当前数据是素数

//            2.判断当前遍历的这个数据是否是素数
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0) {
                    flag = false;
                    break;
                }
            }
//3. 根据判断的结果选择是否输出这个数据,是素数则输出
            if (flag) {
                System.out.print(i+",");
            } 
        }
    }
}

第三题：开发验证码

定义方法实现随机产生一个5位的验证码，每位可能是数字，大写字母、小写字母

分析：定义一个方法，生成验证码返回：方法参数是位数，方法的返回值类型是String.

在方法内部使用for循环生成指定位数的随机符，并连接起来

把连接好的随机符作为一组验证码进行返回。

package com.itheima.demo;

import java.util.Random;

/*定义方法实现随机产生一个5位的验证码，每位可能是数字，大写字母、小写字母*/
public class Test3 {
    public static void main(String[] args) {
//        调用createCode
        System.out.println(createCode(5));

    }

    public static String createCode(int n) {
//        定义一个字符串变量记录生成的随机字符
        String code = "";
        Random r = new Random();
//        定义一个for循环,循环n次,依次生成随机字符
        for (int i = 0; i < n; i++) {
//            生成一个随机字符:英文大小写和数字  (0,1,2)
          int type = r.nextInt(3);
            switch (type) {
                case 0:
                    // 大写字符(65A~65+25Z)
                    char ch = (char) (r.nextInt(26) + 65);
                    code += ch;
                    break;
                case 1:
                    //小写字符
                    char ch1 = (char) (r.nextInt(26) + 97);
                    code += ch1;
                    break;
                case 2:
                    code += r.nextInt(10);//0~9
                    break;
            }
        }
        return code;
    }
}

第四题数组的复制

需求：把一个数组中的元素复制到另一个新数组中去。

public class Test4 {
    public static void main(String[] args) {
        /*
        * 需求：把一个数组中的元素复制到另一个新数组中去。

         */
//        调用方法访问并复制数组
        int[] arr1 = new int[]{12,23,45,56,89,45,23};
        int[] arr2= new int[arr1.length];
        copy(arr1,arr2);
        printArray(arr1);
        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 void copy(int[] arr1, int[] arr2) {
//        正式完成对数组的复制
        for (int i = 0; i < arr1.length; i++) {
         arr2[i] =  arr1[i];
        }
    }
}

第五题：评委打分

package com.itheima.demo;

import java.util.Scanner;

public class Test5 {
    public static void main(String[] args) {
        /*需求：
        在唱歌比赛中，有6名评委给选手打分，分数范围是【0-100】之间的整数
        选手的最后得分去掉最高分最低分后4评委的平均分
        * */
//        定义动态初始化数组
        int[] scores = new int[6];

//        录入6个评委的分数
        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;
        }
//        遍历数组的每个数据,找最大值,最小值,总分
        int max = scores[0], min = scores[0], sum = scores[0];
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] > max) {
                max = scores[i];
            } else if (scores[i] < min) {
                min = scores[i];
            }

//        统计总分
            sum += scores[i];
        }
        System.out.println("最高分："+max+" "+"最低分："+min);
//            统计平均分
        double rs = (sum - max - min) * 1.0 / (scores.length - 2);
        System.out.println("选手的最终得分" + rs);
    }
}

第六题：数字加密

package com.itheima.demo;

import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        /*需求
        * 某系统的数字密码：比如1983，采用加密方式进行传输，规则：先得到每位数，然后每位数都加上5，在对10求余数
        * 最后将所有数字反转，得到一串新数
        * 1 9 8 3
        * +5 6 14 13 8
        * %10 6 4 3 8
        * 反转 8 3 4 6
        * 结果： 8346
        * **/
        System.out.println("请输入需要加密的数字个数");
        Scanner sc = new Scanner(System.in);
        int length = sc.nextInt();
        int[] arr = new int[length];

//        2.录入需要加密的数字
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入加密的第" + (i + i) + "个数字");
            int number = sc.nextInt();
            arr[i] = number;
        }

//       打印数组
        printArry(arr);
//        实现数字密码加密
        for (int i = 0; i < arr.length; i++) {

            arr[i] = (arr[i] + 5) % 10;
        }
//        对核心的数据进行反转
        for (int i = 0, j = arr.length-1; i < j;
        i++, j--) {
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        printArry(arr);

    }

    public static void printArry(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.print("]");
    }
}

第七题：模拟双色球

package com.itheima.demo;

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

/*
  需求：双色球模拟
 */
public class Test7 {
    public static void main(String[] args) {
//        1.随机6个红球号码（1-33.不能重复），随机一个蓝球号码（1——16），采用数组装起来作为中奖号码
        int[] luckNumbers = createLuckNumber();
//        printArray(luckNumbers);
// 2. 调用一个方法让用户输入7个号码，作为用户选号
        int[] userNumbers = usersInputNum();
        printArray(userNumbers);
//  3. 判断中奖情况
     judge(luckNumbers,userNumbers);
    }

    public static void judge(int[] luckNumbers, int[] userNumbers) {
//        判断是否中奖了

//        定义2个变量分别存储红球命中的个数，以及篮球的命中个数
        int redHitNum = 0;
        int blueHitNum = 0;
//        判断红球命中了几个，并统计
        for (int i = 0; i < userNumbers.length - 1; i++) {

            for (int j = 0; j < luckNumbers.length - 1; j++) {
                if (userNumbers[i] == luckNumbers[j]) {
                    redHitNum++;
                    break;
                }
            }
//            蓝球号码是否命中了
            blueHitNum = luckNumbers[6] == userNumbers[6] ? 1 : 0;

//            判断中奖情况
            if (blueHitNum == 1 && redHitNum < 3) {
                System.out.println("恭喜您喜中<h1>5<h1>元");
            } else if (blueHitNum == 1 && redHitNum == 3 || blueHitNum == 0 && redHitNum == 4) {
                System.out.println("恭喜您喜提10元");

            } else if (blueHitNum == 1 && redHitNum == 4 || blueHitNum == 0 && redHitNum == 5) {
                System.out.println("恭喜您喜提200元");
            }else if (blueHitNum == 1 && redHitNum == 5 ) {
                System.out.println("恭喜您喜提3000元");
            }else if (blueHitNum == 0 && redHitNum == 6 ) {
                System.out.println("恭喜您喜提500万元");
            }else if (blueHitNum == 1 && redHitNum == 6) {
                System.out.println("恭喜您喜提1000万元");
            } else {
                System.out.println("感谢您为彩票事业做贡献");

            }
        }
        System.out.println("中奖号码是：");
        printArray(luckNumbers);
        System.out.println("您投注的号码是：");
        printArray(userNumbers);
        System.out.println("您命中了几个红球：" + redHitNum);
        System.out.println("您是否命中蓝球：" + (blueHitNum == 1 ? "是" : "否"));
    }

    public static int[] usersInputNum() {
//        定义一个数组存储7个号码
        int[] number = new int[7];
//录入数据存储元素
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < number.length - 1; i++) {
            System.out.println("请您输入第"+(i+1)+"红球号码（1-33,要求不重复）：");
            int data = sc.nextInt();
//            把接受的数据存入数组中
            number[i] = data;
        }
//        录入蓝球号码
        System.out.println("请输入蓝球的号码（1-16）：");
        number[6] = sc.nextInt();

        return number;
    }

    //    输出的方式
    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[] createLuckNumber() {
//        定义动态初始化数组，存储7个数字
        int[] numbers = new int[7];
//        遍历数组为每个位置生成对应的号码（注意： 遍历前6个位置，生成6个不重复的红球号码，范围是1-33）
        Random r = new Random();
        for (int i = 0; i < numbers.length - 1; i++) {
//            为当前的位置找出不重复的数字
            while (true) {
                int data = r.nextInt(33) + 1;//33个数，1-33（0-32）+1
//                注意：必须判断当前随机的这个号码之前是否出现过，出现过需要重新随机一个，知道不重复，才可存入数组中去
//                定义flag变量 默认data 是没有重复的
                boolean flag = true;
                for (int j = 0; j < i; j++) {
                    if (numbers[j] == data) {
//                        判断这个数据是否之前出现过
                        flag = false;
                        break;
                    }
                }
                if (flag) {
//                    若之前数据没出现则可使用
                    numbers[i] = data;
                    break;
                }
            }
        }
//        为第7个位置生成一个1-16的号码作为蓝球号码
        numbers[numbers.length - 1] = r.nextInt(16) + 1;
        return numbers;
    }
}