标签：Java Scanner int System 笔记第六天 static 数组 public

案例练习

案例一：买飞机票

需求

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

分析

方法是否需要接收数据？需要接收机票原价、当前月份、舱位类型。
方法是否需要返回数据？需要返回计算出的机票优惠价。
方法内部：先使用if判断月份是旺季还是淡季，然后使用switch分支判断是头等舱还是经济舱。

代码

import java.util.Scanner;

public class PlaneDiscount {
    public static void main(String[] args) {
        //输入机票原价、当前月份和机票类型
        Scanner sc =new Scanner(System.in);
        System.out.print("请输入机票原价：");
        double price = sc.nextDouble();
        System.out.print("请输入当前的月份：");
        int month = sc.nextInt();
        System.out.print("请输入机票类型：");
        String type = sc.next();
        
        //调用方法，输出机票优惠价
        System.out.println(planeTicketPrice(price, month, type));
    }

    //计算机票价格（输入机票原价、当前月份和机票类型，返回机票优惠价）
    public static double planeTicketPrice(double price, int month, String type) {
        //判断当前是旺季还是淡季
        if (month <= 10 && month >= 5) {
            //当前是旺季
            //判断是头等舱还是经济舱
            switch (type) {
                case "头等舱":
                    return price * 0.9;
                case "经济舱": //是经济舱
                    return price * 0.85;
                default:
                    return 0;
            }
        } else {
            //当前是淡季
            switch (type) {
                case "头等舱":
                    return price * 0.7;
                case "经济舱":
                    return price * 0.65;
                default:
                    return 0;
            }
        }
    }
}

案例二：生成验证码

需求

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

分析

方法是否需要接收数据？需要接收一个整数, 控制生成验证码的位数。
方法是否需要返回数据？需要返回生成的验证码。
方法内部的业务：使用for循环依次生成每位随机字符，并使用一个String类的变量把每个字符连接起来，最后返回该变量即可。

代码

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

public class IdentifyingCode {
    public static void main(String[] args) {
        //输入验证码长度
        Scanner sc =new Scanner(System.in);
        System.out.print("请输入验证码的长度：");
        int length = sc.nextInt();

        //调用方法，输出目标位数验证码
        System.out.println(identifyingCode(length));
    }

    //生成验证码（输入验证码长度，返回验证码）
    public static String identifyingCode(int length) {
        String code = ""; //要生成的验证码

        Random r = new Random();

        //循环目标位数次
        for (int i = 0; i < length; i++) {
            int type = r.nextInt(3); //随机一个数字来决定这个字符的类型，0：数字，1：大写字母，2：小写字母

            switch (type) {
                case 0:
                    int number = r.nextInt(10); //随机一个数字
                    code += number; //放进验证码
                    break;
                case 1:
                    int upLetter = r.nextInt(26) +65; // 随机一个大写字母
                    code += (char) upLetter; //放进验证码
                    break;
                case 2:
                    int loLetter = r.nextInt(26) +97; // 随机一个小写字母
                    code += (char) loLetter; //放进验证码
                    break;
            }
        }
        return code;
    }
}

案例三：评委打分

需求

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

分析

方法是否需要接收数据？需要接收评委的人数。
方法是否需要返回数据？需要返回计算出的选手最终得分。
方法内部的业务：定义数组，录入评委的分数存入到数组中去，接着，我们就需要遍历数组中的分数，计算出总分，并找出最高分，最低分、最后按照这些数据算出选手最终得分并返回即可。

代码

import java.util.Scanner;

public class AverageScore {
    public static void main(String[] args) {
        //输入评委人数
        Scanner sc =new Scanner(System.in);
        System.out.print("请输入评委人数：");
        int  number= sc.nextInt();

        //调用方法，输出平均分
        System.out.println(getAverageScore(number));
    }

    //（评委打分输入评委人数，返回平均分）
    public static double getAverageScore(int number) {
        int max = 0; //定义最高分
        int min = 100; //定义最低分
        int sum = 0; //定义总分

        //循环录入评委的打分
        for (int i = 0; i < number; i++){
            //获得当前评委的打分
            Scanner sc =new Scanner(System.in);
            System.out.print("请输入评委" + (i + 1) + "的打分([0, 100]之间的整数)：");
            int  score = sc.nextInt();

            //修改最高分，最低分和总分
            max = max > score ? max : score;
            min = min < score ? min : score;
            sum += score;
        }

        double averageScore = (sum - max - min) / (number - 2); //获得最终的平均分

        return  averageScore;
    }
}

案例四：数字加密

需求

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

分析

方法是否需要接收数据？需要接收四位数字密码，进行加密处理。
方法是否需要返回数据？需要返回加密后的结果。
方法内部的业务：将四位数字密码拆分成一个一个的数字，存入到数组中去，遍历数组中的每个数字，按照题目需求进行加密！最后，再把加密后的数字拼接起来返回即可。

代码

import java.util.Scanner;

public class Encrypt {
    public static void main(String[] args) {
        //输入待加密数字
        Scanner sc =new Scanner(System.in);
        System.out.print("请输入要加密的数字：");
        int  number= sc.nextInt();

        //调用方法，输出加密后的结果
        System.out.println(encrypt(number));
    }

    //数字加密（输入待加密的数字，返回加密后的字符串）
    public static String encrypt(int number) {
        //拆分接收到的数字并存入数组
        int[] numbers = new int[4]; //定义一个数组用于存储拆分后的数字
        numbers[3] = number % 10; //存储个位
        numbers[2] = number / 10 % 10; //存储十位
        numbers[1] = number / 100 % 10; //存储百位
        numbers[0] = number / 1000; //存储千位

        //定义一个字符串用于存储加密后的数字
        String code = "";

        //遍历数组，对其进行加密操作
        for (int i = numbers.length - 1; i >= 0; i--){
            numbers[i] += 5; //第一步
            numbers[i] %= 10; //第二步
            code += numbers[i]; //第三步
        }

        return  code;
    }
}

案例五：数组拷贝

需求

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

分析

方法是否需要接收数据？需要接收一个整型数组（原数组）。
方法是否需要返回数据？需要返回一个新的、一模一样的整型数组。
方法内部的业务：创建一个长度一样的整型数组做为新数组，并把原数组的元素对应位置赋值给新数组，最终返回新数组即可。

代码

public class ArrayCopy {
	public static void main(String[] args) {
        int[] arr = {11, 22, 33}; //原数组
        int[] arr1 = copy(arr); //调用方法，复制数组
        printArray(arr1); //调用方法，输出新数组
    }

    //数组拷贝（输入原数组，返回新数组）
    public static int[] copy(int[] arr) {
        //创建新数组
        int[] arrCopy = new int[arr.length];

        //将原数组中的值复制新数组中
        for (int i = 0; i < arr.length; i++) {
            arrCopy[i] = arr[i];
        }

        //返回新数组
        return arrCopy;
    }

    //打印数组（输入数组）
    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] + "]\n" : arr[i] + ", ");
        }
    }
}

案例六：抢红包

需求

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

分析

方法是否需要接收数据？需要接收一个数组，里面是5个金额，表示5个红包。
方法是否需要返回数据？不需要。
方法内部的业务：
- 方案1：写个for循环控制抽奖5次，每次抽奖，都从数组中随机找出一个金额，如果该金额不是0，则代表抽中，接着用0替换该位置处的金额，然后继续下一个粉丝的抽奖；如果抽中的金额发现是0，代表该位置处的红包之前被别人抽走了，则从新从数组中随机找出一个金额，继续判断！直至抽中的金额不是0！
- 方案2：先把数组里面的5个金额打乱顺序，打乱后的顺序就认为是中奖顺序；接着，写个for循环，执行5次，每次都提示抽奖；每次抽奖，都依次取出数组中的每个位置处的金额作为中奖金额即可。

代码

//方案一
public class GrabRedEnvelopes {
    public static void main(String[] args) {
        int[] redEnvelopes = {9, 666, 188, 520, 99999}; //红包
        grabRedEnvelopes(redEnvelopes); //调用方法，随机抽取红包
    }

    //抢红包（输入红包数组，输出抢到的红包）
    public static void grabRedEnvelopes(int[] redEnvelopes) {
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        
        //遍历红包数组，并抽取红包
        for (int i = 0; i < redEnvelopes.length; i++) {
            System.out.print("请按回车抽取红包！");
            while (true) {
                int number = r.nextInt(5);

                //如果这个红包没有被抽取
                if (redEnvelopes[number] != 0) {
                    System.out.println("恭喜你获得了" + redEnvelopes[number] + "元！");
                    redEnvelopes[number] = 0; //将红包设置为已抽取
                    break; //跳出死循环
                }
            }
        }
    }
}


//方案二
public class GrabRedEnvelopes {
	public static void main(String[] args) {
        int[] redEnvelopes = {9, 666, 188, 520, 99999}; //红包
        grabRedEnvelopes(redEnvelopes); //调用方法，随机抽取红包
    }

    //抢红包（输入红包数组，输出抢到的红包）
    public static void grabRedEnvelopes(int[] redEnvelopes) {
        shuffle(redEnvelopes); //打乱数组里的顺序，打乱后的顺序就认为是中奖顺序

        //遍历红包数组，并发出红包
        for (int i = 0; i < redEnvelopes.length; i++) {
            System.out.print("请按回车抽取红包！");
            System.out.println("恭喜你获得了" + redEnvelopes[i] + "元！");
        }
    }

    //打乱数组顺序（输入数组）
    public static void shuffle(int[] arr) {
        Random r =new Random();

        //遍历数组，打乱顺序
        for (int i = 0; i < arr.length; i++) {
            int index = r.nextInt(arr.length); //获得随机索引

            //交换第i个元素和随机索引的元素
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
    }
}

案例七：找素数

需求

判断101~200之间（包含101和200）有多少个素数，并输出所有的素数。

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

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

分析

方法是否需要接收数据？需要接收101以及200，以便找该区间中的素数。
方法是否需要返回数据？需要返回找到的素数个数。
方法内部的业务：使用for循环来产生如101到200之间的每个数; 每拿到一个数，判断该数是否是素数；判断规则是：从2开始遍历到该数的一半的数据，看是否有数据可以整除它，有则不是素数，没有则是素数；根据判定的结果来决定是否输出这个数据（是素数则输出）；最后还需要统计素数的个数并返回。

代码

//方案一
public class FindPrimeNumber {
    public static void main(String[] args) {
        System.out.println(findPrimeNumber(101, 200)); //调用方法，输出所有素数及其数量
    }

    //找素数（输入起始值，返回起始值间的素数个数（包含起始值），并输出其间所有素数）
    public static int findPrimeNumber(int start, int end) {
        int count = 0; //存储素数个数

        //遍历起始值，找出所有素数
        for (int i = start; i <= end; i++){
            boolean flag = true; //标志当前数是素数

            //对于每个数，遍历2到这个数的一半，看是否有数能整除它
            for (int j = 2; j < i / 2; j++) {
                //能整除就不是素数
                if (i % j == 0) {
                    flag = false; //当前数不是素数，修改标志
                    break; //当前数是合数，不在进行后续确认
                }
            }
            
            //若当前数是素数
            if (flag) {
                System.out.println(i); //输出这个素数
                count++; //素数计数加1
            }
        }
        return count;
    }
}


//方案二
public class FindPrimeNumber {
    public static void main(String[] args) {
        System.out.println(findPrimeNumber(101, 200)); //调用方法，输出所有素数及其数量
    }

    //找素数（输入起始值，返回起始值间的素数个数（包含起始值），并输出其间所有素数）
    public static int findPrimeNumber(int start, int end) {
        int count = 0; //存储素数个数

        //遍历起始值，找出所有素数
        OUT: //为外部循环指定标签
        for (int i = start; i <= end; i++){
            //对于每个数，遍历2到这个数的一半，看是否有数能整除它
            for (int j = 2; j < i / 2; j++) {
                //能整除就不是素数
                if (i % j == 0) {
                    continue OUT; //当前数是合数，不在进行后续确认，并结束外部循环的当次执行
                }
            }

            //当前数是素数
            System.out.println(i); //输出这个素数
            count++; //素数计数加1
        }
        return count;
    }
}

案例八：打印九九乘法表

需求

打印出九九乘法表。如下图所示：

分析

方法是否需要接收数据？不需要。
方法是否需要返回数据？不需要。
方法内部的业务：在for循环内嵌套一层for循环，然后按照先行后列的顺序打印出九九乘法表。

代码

public class PrintMultiplicationTable {
	public static void main(String[] args) {
        printMultiplicationTable(); //调用方法，打印九九乘法表
    }

    public static void printMultiplicationTable() {
        //双循环按照先行后列的顺序打印出九九乘法表
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j <= i; j++) {
                if (i == 2 && j == 1 || i == 3 && j == 1) {
                    System.out.print((i + 1) + "×" + (j + 1) + "=" + (i + 1) * (j + 1) + "  "); //打印一个等式，使九九乘法表对齐
                } else {
                    System.out.print((i + 1) + "×" + (j + 1) + "=" + (i + 1) * (j + 1) + " "); //打印一个等式
                }
            }
            
            System.out.println(); //打印完一行后换行
        }
    }
}

案例九：打印三角形

需求

写一个方法，用星号打印出任意层数的三角形。如下所示：

* *

*** * *

***** * * *

******* * * * *

... ...

分析

方法是否需要接收数据？需要接收三角形的层数。
方法是否需要返回数据？不需要。
方法内部的业务：在for循环内嵌套一层for循环，然后按照规律以先行后列的顺序打印出目标行数的三角形。

代码

//左图
import java.util.Scanner;

public class PrintTriangle {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入三角形的层数：");
        int layer = sc.nextInt(); //输入三角形的层数
        printTriangle(layer); //调用方法，打印目标层数的三角形
    }

    public static void printTriangle(int layer) {
        //双循环按照先行后列的顺序打印出三角形
        for (int i = 0; i < layer; i++) {
            //打印空格
            for (int j = 0; j <= layer - i - 1; j++) {
                System.out.print(" ");
            }

            //打印星号
            for (int j = 0; j < 2 * i + 1; j++) {
                System.out.print("*");
            }

            System.out.println(); //打印完一行后换行
        }
    }
}


//右图
import java.util.Scanner;

public class PrintTriangle {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入三角形的层数：");
        int layer = sc.nextInt(); //输入三角形的层数
        printTriangle(layer); //调用方法，打印目标层数的三角形
    }

    public static void printTriangle(int layer) {
        //双循环按照先行后列的顺序打印出三角形
        for (int i = 0; i < layer; i++) {
            //打印空格
            for (int j = 0; j <= layer - i - 1; j++) {
                System.out.print(" ");
            }

            //打印星号
            for (int j = 0; j < 2 * i + 1; j++) {
                System.out.print(j % 2 != 0 ? " " : "*");
            }

            System.out.println(); //打印完一行后换行
        }
    }
}

案例十：模拟双色球

双色球业务介绍

投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1_{33中选择且每个球的号码不能重复；蓝色球号码从1}16中选择。双色球中将条件和奖金表如下图所示：

总体实现步骤分析

写三个方法来实现该业务，三个方法如下：

用于让用户投注一组号码（前6个是红球，最后1个是蓝球），并返回用户投注的号码，无输入。
系统随机一组中奖号码（前6个是红球，最后1个是蓝球），并返回这组中奖号码，无输入。
传入两组号码，用来判断用户投注号码的中奖情况，并输出，无返回值。

方法内部的业务

每次用户投注一个红球号码后，都去调用一个方法来判断这个号码是否已经选择过，如果选择过，让用户重新选号。
每次随机一个1-33之间的红球号码后，都去调用一个方法来判断这个号码是否已经出现过，如果出现过，让系统重新随机。
遍历用户选择的每个红球号码，每遍历一个红球号码时，都去遍历中奖号码数组中的全部红球号码，看当前选的红球号码是否在中奖号码中存在，存在则红球命中数量加1，最后根据红球和蓝球的命中数量，输出用户的中奖情况。

代码

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

public class Lottery {
    public static void main(String[] args) {
        int[] userNumbers = userSelectNumbers(); //用户投注一组号码
        int[] luckyNumbers = createLuckyNumbers(); //系统随机一组号码
        printArray(userNumbers);
        printArray(luckyNumbers);
        judge(userNumbers, luckyNumbers); //判断中奖情况，并输出
    }

    //用户投注一组号码（无输入，无输出，返回用户投注的号码）
    public static int[] userSelectNumbers() {
        int[] userNumbers = new int[7]; //定义一个数组用于保存用户选择的号码

        Scanner sc = new Scanner(System.in);

        //遍历数组，输入所有红色球号码
        for (int i = 0; i < 6; i++) {
            System.out.print("请输入第" + (i + 1) + "个红色球的号码（从1~33中选择且每个球的号码不能重复）：");
            while (true) {
                int input = sc.nextInt();

                //判断输入值是否合法
                if (input >= 1 && input <= 33) {
                    //判断输入值是否重复
                    if (!inArray(input, userNumbers)) {
                        // 没有重复，跳出循环
                        userNumbers[i] = input;
                        break;
                    } else {
                        //重复了，重新输入
                        System.out.print("号码重复了，请重新输入：");
                    }
                } else {
                    System.out.print("号码错误，请重新输入：");
                }
            }
        }

        //输入蓝色球号码
        System.out.print("请输入蓝色球的号码（从1~16中选择）：");
        int input = 0;
        while (true) {
            input = sc.nextInt();
            //判断输入是否合法
            if (input >= 1 && input <= 16) {
                break;
            } else {
                System.out.print("号码错误，请重新输入：");
            }
        }
        userNumbers[6] = input;

        return userNumbers;
    }

    //系统随机一组号码（无输入，无输出，返回系统随机的号码）
    public static int[] createLuckyNumbers() {
        int[] luckyNumbers = new int[7]; //定义一个数组用于保存系统生成的号码

        Random r = new Random();

        //遍历数组，随机生成红色球号码
        for (int i = 0; i < 6; i++) {
            while (true) {
                int number = r.nextInt(33) + 1;

                //判断输入值是否重复
                if (!inArray(number, luckyNumbers)) {
                    luckyNumbers[i] = number;
                    break;
                }
            }
        }

        //随机生成蓝色球号码
        int number = r.nextInt(16) + 1;
        luckyNumbers[6] = number;

        return luckyNumbers;
    }

    //判断中奖情况（输入用户投注的号码和系统随机的号码，输出中奖情况，无返回值）
    public static void judge(int[] userNumbers, int[] luckyNumbers) {
        //定义两个整型变量分别存储红球和蓝球的命中数量
        int redBingo = 0;
        int blueBingo = 0;

        //遍历两个数组，计算红球命中数量
        for (int i = 0; i < 6; i++) {
            for (int j =0; j < 6; j++) {
                if (userNumbers[i] == luckyNumbers[j]) {
                    redBingo++;
                }
            }
        }

        //计算蓝球命中数量
        if (userNumbers[6] == luckyNumbers[6]) {
            blueBingo++;
        }

        //判断中奖情况并输出
        System.out.println("命中红球" + redBingo + "个，蓝球" + blueBingo + "个！");
        if (blueBingo == 1) {
            switch (redBingo) {
                case 6:
                    System.out.println("恭喜你，中了一等奖，奖金1000万！");
                    break;
                case 5:
                    System.out.println("恭喜你，中了三等奖，奖金3000元！");
                    break;
                case 4:
                    System.out.println("恭喜你，中了四等奖，奖金200元！");
                    break;
                case 3:
                    System.out.println("恭喜你，中了五等奖，奖金10元！");
                    break;
                default:
                    System.out.println("恭喜你，中了六等奖，奖金5元！");
            }
        }
        if (blueBingo == 0) {
            switch (redBingo) {
                case 6:
                    System.out.println("恭喜你，中了二等奖，奖金500万！");
                    break;
                case 5:
                    System.out.println("恭喜你，中了四等奖，奖金200元！");
                    break;
                case 4:
                    System.out.println("恭喜你，中了五等奖，奖金10元！");
                    break;
                default:
                    System.out.println("很遗憾，你没有中奖");
            }
        }
    }

    //判断某个数字是否在数组中，true代表在，false代表不在(输入要查看的数字和数组，无输出，返回布尔值)
    public static boolean inArray(int number, int[] array) {
        //遍历数组，依次比较每个值
        for (int i = 0; i < array.length; i++){
            if (number == array[i]) {
                return true; //数字在数组中
            }
        }
        return false; //数字不在数组中
    }

    //打印数组（输入数组，输出数组的打印值，无返回值）
    public static void printArray(int[] array) {
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            System.out.print(i != array.length - 1 ? array[i] + ", " : array[i]);
        }
        System.out.println("]");
    }
}

标签：Java,Scanner,int,System,笔记,第六天,static,数组,public
From： https://www.cnblogs.com/zgg1h/p/18053797

Java学习笔记——第六天