一些Java练手小程序的记录。

涉及知识点

• 变量、数组
• 运算符：基本运算符、关系运算符、逻辑运算符
• 流程控制：if语句、switch语句、for循环、while循环、do...while循环、死循环、循环嵌套
• 跳转关键字：break、continue、return
• 方法

案例一：买飞机票

需求

机票价格按照淡季旺季、头等舱和经济舱收费，用户输入机票原价、月份和座舱等级

机票售价计算方案如下：

• 旺季（5~10月）：头等舱9折，经济舱8.5折
• 淡季（11~4月）：头等舱7折，经济舱6.5折

分析

使用扫描器获取用户输入的机票原价、月份、座舱等级，调用方法返回机票的最终售价

方法设计：传入机票原价、月份、座舱等级作为参数，使用if语句判断是淡季还是旺季，使用switch语句判断是头等舱还是经济舱，机票最终售价作为返回值返回。

代码实现

import java.util.Scanner;

public class buy_air_tickets {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("welcome to the airfare calculator");
            System.out.println("enter 1 calculate the airdare and enter 2 exit the system");
            int menu_input = sc.nextInt();
            if (menu_input == 1) {
                System.out.println("please enter the original price");
                double original_prince = sc.nextDouble();
                System.out.println("please enter the month");
                int month = sc.nextInt();
                System.out.println("please enter whitch cockpit would you like (first/second)");
                String cockpit = sc.next();
                double airfare = airfare_calculate(original_prince, month, cockpit);
                System.out.println("the airfare is " + airfare);
            }
            else {
                break;
            }
        }
        sc.close();
        System.exit(0);
    }

    public static double airfare_calculate (double original_prince,  int month, String cockpit) {
        double airfare = 0;
        if (month >= 5 && month <= 10) {
            switch (cockpit) {
                case "first" :
                    airfare = original_prince * 0.9;
                    break;
                case "second" :
                    airfare = original_prince * 0.85;
                    break;
                default :
                    break;
            }
        }
        else {
            switch (cockpit) {
                case "first" :
                    airfare = original_prince * 0.7;
                    break;
                case "second" :
                    airfare = original_prince * 0.65;
                    break;
                default :
                    break;
            }
        }
        return airfare;
    }
}

案例二：找素数

素数：指在大于1的自然数中，除了1和该数自身外，无法被其他自然数整除的数。

需求

找出101~200之间所有素数并输出

分析

• 使用循环依次获取101~200之间的每个数
• 每获取一个数，就判断其是否是素数
• 判断是否为素数的规则：从2开始遍历到该数的一半，若都没有整数可以整除它，则它是素数

代码实现

public class find_the_primeNumber {
    public static void main(String[] args) {
        System.out.println("101~200之间的素数有:");
        for (int i = 101; i <= 200; i++) {
            int j;
            boolean flag = true;
            for (j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.printf("%d ", i);
            }
        }
        System.out.println();
    }
}

案例三：随机验证码

需求

定义方法随机产生一个5位的验证码，可以是大写字母、小写字母和数字。

分析

• 定义一个方法，方法的参数为产生验证码的位数，返回值为String类型。
• 方法内部使用for循环逐位产生随机字符，最后连接起来返回。

代码实现

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

public class verification_code {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Please enter the number of digits of the verification code to be generated");
        int n = sc.nextInt();
        String verification_code = code(n);
        System.out.println("verification_cod: " + verification_code);
        sc.close();
    }

    public static String code(int n) {
        Random ra = new Random();
        String verification_code = "";
        for (int i = 0; i < n; i++) {
            int kind = ra.nextInt(3);
            switch (kind) {
                case 0:
                    verification_code += (char)(ra.nextInt(10) + 48);
                    break;
                case 1:
                    verification_code += (char)(ra.nextInt(26) + 65);
                    break;
                default:
                    verification_code += (char)(ra.nextInt(26) + 97);
            }
        }
        return verification_code;
    }
}

案例四：复制数组

需求

定义一个方法，完成对任意长度的整型数组的复制，并将复制之后的数组返回

分析

将指定数组作为参数传入方法，在方法内部定义一个与原数组长度相同的数组，使用循环将原数组的每个元素依次复制给新数组的相同位置，最后将新定义的数组返回即可。

代码实现

public class copy_array {
    public static void main(String[] args) {
        int array_a[] = new int[] {1,2,3,4,5,6,7,8,9,10};
        System.out.printf("array_a: ");
        for (int i = 0; i < array_a.length; i++) {
            System.out.printf("%d ", array_a[i]);
        }
        System.out.println();
        int array_b[] = copy_array_method(array_a);
        System.out.printf("array_b: ");
        for (int i = 0; i < array_b.length; i++) {
            System.out.printf("%d ", array_b[i]);
        }
        System.out.println();
    }

    public static int[] copy_array_method(int array_a[]) {
        int array_b[] = new int[array_a.length];
        for (int i = 0; i < array_a.length; i++) {
            array_b[i] = array_a[i];
        }
        return array_b;
    }
}

案例五：评委打分

需求

在歌唱比赛中，有6名评委给选手打分，分数范围是0~100之间的整数。选手最后的得分为：去掉一个最高分，去掉一个最低分，剩下四名评委的打分取平均分。

分析

• 将6名评委的打分存入数组
• 遍历数组找到最高分和最低分
• 第二次遍历时，不等于最高分或最低分的打分累加，最后求平均分

代码实现

import java.util.Scanner;

public class judge_score {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int score[] = new int [6];
        for (int i = 0; i < 6; i++) {
            System.out.printf("please enter the judge%d's score:", i + 1);
            score[i] = sc.nextInt();
        }
        double average_score = average_score(score);
        System.out.println("the average score is: " + average_score);
        sc.close();
    }

    public static double average_score(int score[]) {
        double average_score;
        int max = score[0], min = score[0], sum = 0;
        for (int i = 0; i < score.length; i++) {
            if (score[i] > max) {
                max = score[i];
            }
            if (score[i] < min) {
                min = score[i];
            }
        }
        for (int i = 0; i < score.length; i++) {
            if (score[i] != max & score[i] != min) {
                sum += score[i];
            }
        }
        average_score = sum / 4;
        return average_score;
    }
}

案例六：数字加密

需求

给定一个四位整数，对该数字进行加密，加密规则如下：

先获取每一位数，对每位数都先加上5，再对10求余数，最后将得到的所有数字反转输出。

分析

• 分离每一位数
• 将得到的数字按规则运算后逆序存入一个整型数组
• 遍历输出该数组

代码实现

import java.util.Scanner;

public class password {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.printf("Please enter the four digits you want to encrypt: ");
        int number = sc.nextInt();
        encrypt(number);
        sc.close();
    }
    
    public static void encrypt(int number) {
        int thousand = number / 1000;
        int hundred = (number %1000) / 100;
        int ten = (number % 100) / 10;
        int individual = number % 10;
        int password[] = new int[4];
        thousand = (thousand + 5) % 10;
        hundred = (hundred + 5) % 10;
        ten = (ten + 5) % 10;
        individual = (individual + 5) % 10;
        password[0] = individual;
        password[1] = ten;
        password[2] = hundred;
        password[3] = thousand;
        System.out.printf("the password is: ");
        for (int i = 0; i < password.length; i++) {
            System.out.printf("%d", password[i]);
        }
        System.out.println();
    }
}

案例七：模拟双色球系统

需求

开发一个模拟双色球抽奖系统

双色球游戏规则如下：

• 投注号码由6个红球号码和1个蓝球号码组成
• 红球号码从1~33中选出，没有重复号码
• 蓝球号码从1~16中选出，没有重复号码

要求每次随机生成一组中奖号码，并根据用户的输入判断其是否中奖。

中奖条件：

分析

定义两个方法：

1. 随机产生中奖号码
   • 定义一个整型数组luky_number，用来存放中奖号码。前6位用来存放红球号码，最后一位用来存放蓝球号码。
   • 使用while循环，当红球位未满时，循环产生1~33之间的随机数，每产生一个，遍历一次数组，若该数字未出现过，则放入数组
   • 使用冒泡排序算法，保证随机产生的中奖号码按从小到大排序
   • 随机产生一个1~16之间的数字，放入蓝球位
   • 返回中奖号码
2. 以用户输入的号码和随机产生的中奖号码为参数，判断用户是否中奖以及中奖类型
   • 定义两个变量red_marker和blue_marker并初始化为0
   • 使用循环嵌套，逐个匹配在中奖号码和用户输入的号码，若红球匹配成功一个，则red_marker加一。蓝球同理。
   • 使用if分支结构，根据红球和蓝球的命中情况判断中奖等级

代码实现

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

public class two_color_ball {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int user_number[] = new int[7];
        int lucky_number[] = generate_lucky_number();

        //读取用户输入
        System.out.println("please enter your red ball number:");
        for (int i = 0; i < 6; i++) {
            user_number[i] = sc.nextInt();
        }
        System.out.println("please enter your blue ball number:");
        user_number[6] = sc.nextInt();

        //判断中奖情况
        match(user_number, lucky_number);
        sc.close();
    }

    //随机生成中奖号码
    public static int[] generate_lucky_number() {
        Random ra = new Random();
        int lucky_number[] = new int[] {0,0,0,0,0,0,0};
        int red_ball, blue_ball;
        int index = 0;
        while (index < 6) {
            red_ball = ra.nextInt(32) + 1;
            int exist = 0;
            for (int i = 0; i < 7; i++) {
                if (lucky_number[i] == red_ball) {
                    exist = 1;
                    break;
                }
            }
            if (exist == 0) {
                lucky_number[index] = red_ball;
                index += 1;
            }
        }
        blue_ball = ra.nextInt(16) + 1;
        lucky_number[6] = blue_ball;

        //冒泡排序
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 5; j++) {
                if (lucky_number[j] > lucky_number[j+1]) {
                    int temp = lucky_number[j];
                    lucky_number[j] = lucky_number[j+1];
                    lucky_number[j+1] = temp;
                }
            }
        }

        return lucky_number;
    }

    //检测中奖情况
    public static void match(int user_number[], int lucky_number[]) {
        int red = 0, blue = 0;
        
        for (int i = 0; i < 6; i++) {
            for (int j = i; j < 5; j++) {
                if (user_number[j] > user_number[j+1]) {
                    int temp = user_number[j];
                    user_number[j] = user_number[j+1];
                    user_number[j+1] = temp;
                }
            }
        }

        //匹配红球
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                if (lucky_number[i] == user_number[j]) {
                    red += 1;
                    break;
                }
            }
        }

        //匹配蓝球
        if (lucky_number[6] == user_number[6]) { 
            blue += 1;
        }

        //判断中奖情况
        if (red == 6 & blue == 1) {
            System.out.println("恭喜你中了一等奖!");
        }
        else if (red == 6 & blue == 0) {
            System.out.println("恭喜你中了二等奖!");
        }
        else if (red == 5 & blue == 1) {
            System.out.println("恭喜你中了三等奖!");
        }
        else if (red == 5 & blue == 0) {
            System.out.println("恭喜你中了四等奖!");
        }
        else if (red == 4 & blue == 1) {
            System.out.println("恭喜你中了四等奖!");
        }
        else if (red == 4 & blue == 0) {
            System.out.println("恭喜你中了五等奖!");
        }
        else if (red == 3 & blue == 1) {
            System.out.println("恭喜你中了五等奖!");
        }
        else if (red == 2 & blue == 1) {
            System.out.println("恭喜你中了六等奖!");
        }
        else if (red == 1 & blue == 1) {
            System.out.println("恭喜你中了六等奖!");
        }
        else if (red == 0 & blue == 1) {
            System.out.println("恭喜你中了六等奖!");
        }
        else {
            System.out.println("谢谢惠顾!");
        }

        //打印中奖号码
        System.out.printf("red ball: ");
        for (int i = 0; i < 6; i++) {
            System.out.printf("%d, ", lucky_number[i]);
        }
        System.out.printf("\nblue ball: %d\n", lucky_number[6]);
    }
}