编程导航会员会员
登录/注册

企业级代码不是人写的，注释错了都要改

排序方法需要合并

▼
import
复制代码

/**
 * day29:定义Worker类（姓名/工种/工龄/评分），创建2个师傅对象并打印信息。
 * day30:给Worker加3种构造：无参/姓名+工种/全字段，分别创建对象验证；用this区分同名参数
 * day31：给Worker加static计数器count，每创建一个对象+1，打印当前平台注册师傅总数
 * day32：Worker字段全改private；setWorkYears里校验工龄不能<0（负数就置0或抛提示），setScore校验0-5分
 * day33：师傅管理小程序：Worker数组容量10，支持添加、按名字查找、打印全部（遍历调用toString前先自己拼信息）
 * day34：在day33基础上加：按工种筛选、按评分排序、统计平均工龄，全部封装成方法
 * day35：默写Worker类（封装+构造器+计数器版） *
 * <p>
 * 菜单：1-增加师傅 |2-按名字模糊查找 |3-打印全部 |4-按工种筛选 |5-按评分排序 |6-统计平均工龄 |exit-退出
 * 方法：
 * 1. addWorker()
 * 2. searchWorker()
 * 3. printAllWorkers()
 * 4. filterByJobType()
 * 5. sortByScore()
 * 6. doByScore()
 * 7. calcAvgWorkYears()
 * 8. inputtedName()
 * 9. inputtedJobType()
 * 10. inputtedWorkYears()
 * 11. inputtedScore()
 * 12. getMenuItemNumber()
 * 13. judgeInput()
 */

public class Day34WorkerTest {
    //  定义程序、菜单、工种字典
    private static final String APP_TITLE = "师傅管理小程序";
    private static final String APP_LINE = "----------";
    private static final String MENU_TIP = "1-增加师傅 |2-按名字模糊查找 |3-打印全部 |4-按工种筛选 |5-按评分排序 |6-统计平均工龄 |exit-退出";
    private static final String MENU_INPUT_TIP = "请输入您的选择：";
    private static final String EXIT_KEY_WORD = "EXIT";
    private static final String EXIT_TIP = "Bye. thank you.";
    private static final String[] JOB_TYPE_DICT = {"电工", "泥工", "瓦工", "木工", "美缝工", "油漆工", "监理", "空调安装工", "智能调试"};
    private static final String PRINT_ALL_WORKERS_TITLE = "打印全部师傅信息";
    private static final String PRINT_NO_DATA = "没有记录，无法打印！";
    private static final String CALCULATE_AVERAGE_WORK_YEARS_TITLE = "统计平均工龄";
    private static final String CALCULATE_AVERAGE_WORK_YEARS_NO_DATA = "没有记录，无法统计！";
    private static final String PRINT_AVERAGE_WORK_YEARS_TIP = "师傅平均工龄是：";
    private static final String SEARCH_WORKER_TITLE = "按照姓名模糊查找";
    private static final String SEARCH_WORKER_NO_DATA = "没有记录，无法查找！";
    private static final String PRINT_SEARCH_WORKER_TIP = "查找到的记录有：";
    private static final String SORT_BY_SCORE_TITLE = "按评分排序";
    private static final String SORT_BY_SCORE_NO_DATA = "没有记录，无法排序！";
    private static final String FILTER_BY_JOB_TYPE_TITLE = "按工种筛选";
    private static final String FILTER_BY_JOB_TYPE_NO_DATA = "没有记录，无法筛选！";

    //  定义输入的提示词
    private static final String INPUT_NAME_TIP = "请输入姓名【exit-返回】：";
    private static final String INPUT_JOB_TYPE_TIP = "请输入工种【exit-返回】：";
    private static final String INPUT_WORK_YEARS_TIP = "请输入工龄（0-70）【exit-返回】：";
    private static final String INPUT_SCORE_TIP = "请输入评分（0-5）【exit-返回】：";
    private static final String INPUT_SORT_BY_SCORE = "请选择排序方式（1-升序 |2-降序）【exit-返回】：";
    private static final String PREFIX_FILTER_BY_JOB_TYPE_TIP = "请选择工种筛选的序号";
    private static final String SUFFIX_FILTER_BY_JOB_TYPE_TIP = "【exit-返回】）：";

    //  定义其他提示词
    private static final String INPUT_IS_BLANK_TIP = "空的输入，请重新输入！";
    private static final String INPUT_IS_INVALID_TIP = "无效的输入，请重新输入！";
    private static final String MSG_JOB_TYPE_NOT_EXIST = "该工种暂未收录，已记录上报，审核通过后全平台可用";
    private static final String ERROR_OUT_OF_RANGE_WORK_YEARS = "工龄不能小于 0 或 大于 70 ！";
    private static final String ERROR_OUT_OF_RANGE_SCORE = "评分不能小于 0 或 大于 5 ！";
    private static final String ERROR_OUT_OF_SIZE_WORKERS = "数据已满仓，无法添加！";
    private static final String DATA_SAVED_SUCCESSFULLY = "数据已成功保存！";

    //  定义正则（主菜单、工龄、评分、工种筛选菜单）
    private static final String MAIN_MENU_ITEM_NUMBER_REGEX = "[1-6]";
    private static final String WORK_YEARS_REGEX = "\\d+";
    private static final String SCORE_REGEX = "[0-5](\\.[0-9])?";
    private static final String SORT_BY_SCORE_REGEX = "[1-2]";

    //  定义哨兵值:-1(exit) -2(isBlank) -3(invalid)
    private static final int SENTINEL_IS_EXIT = -1;
    private static final int SENTINEL_IS_INVALID = -3;

    //  定义用户数组大小、增加用户的计数器(count 是"名册"的状态，不是"师傅"的属性，群体计数是看管数组的那一方的事）
    private static final int WORKERS_SIZE = 10;
    private static Worker34[] workers = new Worker34[WORKERS_SIZE];
    private static int addWorkerCount = 0;
    //  模糊查找用户的计数器降级（降级为searchWorker局部变量，每次搜索清零、不跨方法存活，没资格当全局）

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (true) {
            System.out.println(APP_TITLE);
            System.out.println(APP_LINE.repeat(6));
            System.out.println(MENU_TIP);
            System.out.print(MENU_INPUT_TIP);

            String inputtedStr = judgeInput(in);
            if (inputtedStr == null) {
                System.out.println(EXIT_TIP);
                break;
            }

            int menuItemNumber = getMenuItemNumber(inputtedStr, MAIN_MENU_ITEM_NUMBER_REGEX);
            switch (menuItemNumber) {
                case 1 -> {
                    addWorker(in);
                }
                case 2 -> {
                    searchWorker(in);
                }
                case 3 -> {
                    printAllWorkers();
                }
                case 4 -> {
                    filterByJobType(in);
                }
                case 5 -> {
                    sortByScore(in);
                }
                case 6 -> {
                    calcAvgWorkYears();
                }
                default -> {
                }
            }
            ;
        }
    }

    /**
     * 增加师傅
     *
     * @param in 键盘输入
     */
    public static void addWorker(Scanner in) {
        //  1. 判断是否满员，是就返回
        if (addWorkerCount == WORKERS_SIZE) {
            System.out.println(ERROR_OUT_OF_SIZE_WORKERS);
            return;
        }
        //  2. 调用方法
        String name = inputtedName(in);
        if (name == null) {
            return;
        }
        String jobType = inputtedJobType(in);
        if (jobType == null) {
            return;
        }
        int workYears = inputtedWorkYears(in);
        if (workYears == SENTINEL_IS_EXIT) {
            return;
        }
        double score = inputtedScore(in);
        if (score == SENTINEL_IS_EXIT) {
            return;
        }

        workers[addWorkerCount] = new Worker34(name, jobType, workYears, score);
        addWorkerCount++;
        System.out.println(APP_LINE.repeat(6));
        System.out.println(DATA_SAVED_SUCCESSFULLY);
        System.out.println("当前有：" + addWorkerCount + " 位师傅.");
        System.out.println(APP_LINE.repeat(6));
        System.out.println(workers[addWorkerCount - 1]);
    }

    /**
     * 按姓名模糊查找
     *
     * @param in 键盘输入
     */
    public static void searchWorker(Scanner in) {
        int foundCount = 0; //  找到符合的记录计数器
        int[] foundIdxs = new int[addWorkerCount];  //  存放符合的记录的下标

        System.out.print(APP_LINE.repeat(3));
        System.out.print(SEARCH_WORKER_TITLE);
        System.out.print(APP_LINE.repeat(3) + "\n");

        if (addWorkerCount == 0) {   //  1. 判断是否有记录，无就提示并返回
            System.out.println(SEARCH_WORKER_NO_DATA);
        } else {
            //  2. judgeInput()
            System.out.print(INPUT_NAME_TIP);
            String inputStr = inputtedName(in);
            if (inputStr == null) {  //   3. 拦截 exit，避免 contains(null)
                return;
            }
            //  4. 获取输入，String.contains()或String.indexOf()
            for (int i = 0; i < addWorkerCount; i++) {
                if (workers[i].getName().contains(inputStr)) {   //  5. 有符合的记录就保存下标，并继续查找
                    foundIdxs[foundCount] = i;
                    foundCount++;
                }
            }
            //  4.1 查找到符合记录的计数器
            System.out.print(PRINT_SEARCH_WORKER_TIP + foundCount + " 条.\n");
            if (foundCount > 0) {
                for (int j = 0; j < foundCount; j++) {  //  4.2 根据保存的下标，打印记录
                    System.out.println("[第 " + (j + 1) + " 条记录] " + workers[foundIdxs[j]]);
                }
            }
        }
    }

    /**
     * 打印全部师傅的信息，分为无记录提示，有记录打印
     */
    public static void printAllWorkers() {
        System.out.print(APP_LINE.repeat(3));
        System.out.print(PRINT_ALL_WORKERS_TITLE);
        System.out.print(APP_LINE.repeat(3) + "\n");

        if (addWorkerCount == 0) {     //  没有记录
            System.out.println(PRINT_NO_DATA);
        } else {      //  有记录
            for (int i = 0; i < addWorkerCount; i++) {
                System.out.println("[第 " + (i + 1) + " 条记录] " + workers[i]);
            }
        }
    }

    public static void filterByJobType(Scanner in) {
        int jobTypeCount = 0; //  不同工种的计数器
        String[] jobTypeData = new String[addWorkerCount];  //  存放不同工种的数据
        StringBuilder menu = new StringBuilder();  //  不同工种拼接

        while (true) {
            System.out.print(APP_LINE.repeat(3));
            System.out.print(FILTER_BY_JOB_TYPE_TITLE);
            System.out.println(APP_LINE.repeat(3));

            //  1. 判断是否有记录，无就提示并返回
            if (addWorkerCount == 0) {
                System.out.println(FILTER_BY_JOB_TYPE_NO_DATA);
                break;
            }
            //  2. 获取源记录中工种的种类，并生成菜单，拼接前缀 + 工种 + 后缀，以便用户选择
            if (addWorkerCount == 1) {
                System.out.println("有 " + addWorkerCount + " 条记录");
                System.out.println(workers[0]);
                break;
            }
            if (addWorkerCount > 1) {
                for (int i = 0; i < addWorkerCount; i++) {
                    String type = workers[i].getJobType();
                    boolean isExist = false;
                    //  检查jobTypeData[]是否存在
                    for (int j = 0; j < jobTypeCount; j++) {
                        //  如果相同就退出
                        if (type.equalsIgnoreCase(jobTypeData[j])) {
                            isExist = true;
                            break;
                        }
                    }
                    //  不相同就写入
                    if (!isExist) {
                        jobTypeData[jobTypeCount++] = type;
                    }
                }
                //  去重工种的数组生成菜单字符串
                menu.setLength(0);
                for (int i = 0; i < jobTypeCount; i++) {
                    menu.append(i + 1).append(" - ").append(jobTypeData[i]).append(" |");
                }
                String menuStr = menu.toString();
                System.out.print(PREFIX_FILTER_BY_JOB_TYPE_TIP + "（" + menuStr + SUFFIX_FILTER_BY_JOB_TYPE_TIP);
                String inputStr = judgeInput(in);   //  预处理键盘输入
                if (inputStr == null) {
                    break;
                }
                //  生成菜单正则
                String menuRegex = "[1-" + jobTypeCount + "]";
                int menuItemNumber = getMenuItemNumber(inputStr, menuRegex);
                if ((menuItemNumber > jobTypeCount) || (menuItemNumber < 1)) {
                    System.out.println(INPUT_IS_INVALID_TIP);
                    continue;
                }
                //  按照选择的工种，遍历查找,找到就保存下标，继续查找
                int[] foundIdxs = new int[addWorkerCount];
                int foundCount = 0;
                for (int i = 0; i < addWorkerCount; i++) {
                    if (workers[i].getJobType().equalsIgnoreCase(jobTypeData[menuItemNumber - 1])) {
                        foundIdxs[foundCount++] = i;
                    }
                }
                System.out.println("筛选到 " + foundCount + " 条数据");
                for (int i = 0; i < foundCount; i++) {
                    System.out.println(workers[foundIdxs[i]]);
                }
                break;
            }
        }
    }

    public static void sortByScore(Scanner in) {
        while (true) {
            System.out.print(APP_LINE.repeat(3));
            System.out.print(SORT_BY_SCORE_TITLE);
            System.out.print(APP_LINE.repeat(3));

            if (addWorkerCount == 0) {
                System.out.println(SORT_BY_SCORE_NO_DATA);
                break;
            } else {
                System.out.print("\n" + INPUT_SORT_BY_SCORE);
                String inputStr = judgeInput(in);   //  1. 用户选择升序还是降序
                if (inputStr == null) {
                    return;
                }

                doByScore(inputStr);    //  2. 按用户选择排序
                break;
            }
        }
    }

    public static void doByScore(String sortOrderStr) {
        if (!sortOrderStr.matches(SORT_BY_SCORE_REGEX)) {
            System.out.println(INPUT_IS_INVALID_TIP);
            return;
        }
        int sortOrderNum = Integer.parseInt(sortOrderStr);
        if (sortOrderNum == 1) {     //  升序
            for (int i = 0; i < addWorkerCount - 1; i++) {
                for (int j = 0; j < addWorkerCount - 1 - i; j++) {
                    boolean needSwap = (sortOrderNum == 1)
                            ? workers[j].getScore() > workers[j + 1].getScore()   // 升序：左>右才换
                            : workers[j].getScore() < workers[j + 1].getScore();  // 降序：左<右才换
                    if (needSwap) {
                        Worker34 t = workers[j];
                        workers[j] = workers[j + 1];
                        workers[j + 1] = t;
                    }
                }
            }
        }
        if (sortOrderNum == 2) {     //  降序
            for (int i = 0; i < addWorkerCount - 1; i++) {
                for (int j = 0; j < addWorkerCount - 1 - i; j++) {
                    boolean needSwap = (sortOrderNum == 1)
                            ? workers[j].getScore() > workers[j + 1].getScore()   // 升序：左>右才换
                            : workers[j].getScore() < workers[j + 1].getScore();  // 降序：左<右才换
                    if (needSwap) {
                        Worker34 t = workers[j];
                        workers[j] = workers[j + 1];
                        workers[j + 1] = t;
                    }
                }
            }
        }
        // 排序完打印
        printAllWorkers();
    }

    /**
     * 计算全部师傅的平均工龄
     */
    public static void calcAvgWorkYears() {
        if (addWorkerCount == 0) {     //  1. 判断是否有记录，无就提示并返回
            System.out.println(CALCULATE_AVERAGE_WORK_YEARS_NO_DATA);
        } else {
            System.out.print(APP_LINE.repeat(3));
            System.out.print(CALCULATE_AVERAGE_WORK_YEARS_TITLE);
            System.out.print(APP_LINE.repeat(3) + "\n");
            double avgWorkYears = 0.0;
            //  2. 遍历计算平均值并返回
            for (int i = 0; i < addWorkerCount; i++) {
                avgWorkYears += workers[i].getWorkYear();
            }
            avgWorkYears = Math.round((avgWorkYears / addWorkerCount) * 10) / 10;   //  3. 获取师傅的数量，计算平均值
            System.out.println("当前有：" + addWorkerCount + " 位师傅.");
            System.out.println(PRINT_AVERAGE_WORK_YEARS_TIP + avgWorkYears + "年");
        }
    }

    /**
     * 获取姓名
     *
     * @param in 键盘输入
     * @return 返回字符串
     */
    public static String inputtedName(Scanner in) {
        String inputtedStr;
        while (true) {
            System.out.print(INPUT_NAME_TIP);

            inputtedStr = judgeInput(in);
            if (inputtedStr == null) {
                break;
            }
            if (inputtedStr.isBlank()) {
                continue;
            }
            break;
        }
        return inputtedStr;
    }

    /**
     * 获取工种
     *
     * @param in 键盘输入
     * @return 返回字符串
     */
    public static String inputtedJobType(Scanner in) {
        String inputtedStr;
        while (true) {
            System.out.print(INPUT_JOB_TYPE_TIP);

            inputtedStr = judgeInput(in);
            if (inputtedStr == null) {
                break;
            }
            if (inputtedStr.isBlank()) {
                System.out.println(INPUT_IS_BLANK_TIP);
                continue;
            }
            //  2. 获取输入，判断是否在字典里，不在就提示并重新输入
            boolean isHit = false;
            for (String type : JOB_TYPE_DICT) {
                if (type.equalsIgnoreCase(inputtedStr)) {
                    isHit = true;
                    break;
                }
            }
            if (!isHit) {
                System.out.println(MSG_JOB_TYPE_NOT_EXIST);
            } else {
                return inputtedStr;
            }
        }
        return null;
    }

    /**
     * 获取工龄
     *
     * @param in 键盘输入
     * @return int，0-70
     */
    public static int inputtedWorkYears(Scanner in) {
        int inputtedNum = 0;
        while (true) {
            System.out.print(INPUT_WORK_YEARS_TIP);
            String inputStr = judgeInput(in);   //  1. judgeInput()
            if (inputStr == null) {
                return SENTINEL_IS_EXIT;
            }
            if (inputStr.isBlank()) {
                System.out.println(INPUT_IS_BLANK_TIP);
                continue;
            }
            if (!inputStr.matches(WORK_YEARS_REGEX)) {  //  2. 获取输入，正则（INT_WORK_YEARS_REGEX)判断，不符合就提示并重新输入
                System.out.println(INPUT_IS_INVALID_TIP);
            } else {
                inputtedNum = Integer.parseInt(inputStr);
                if (inputtedNum < 0 || inputtedNum > 70) {  //  3. 判断，小于0拦，大于70拦（0<= workYears <= 70放行）
                    System.out.println(ERROR_OUT_OF_RANGE_WORK_YEARS);
                    continue;
                }
                return inputtedNum;
            }
        }
    }

    /**
     * 获取评分
     *
     * @param in 键盘输入
     * @return double类型 0-5
     */
    public static double inputtedScore(Scanner in) {
        double inputtedNum = 0.0;
        while (true) {
            System.out.print(INPUT_SCORE_TIP);
            String inputStr = judgeInput(in);
            if (inputStr == null) {
                return SENTINEL_IS_EXIT;
            }
            if (inputStr.isBlank()) {
                System.out.println(INPUT_IS_BLANK_TIP);
                continue;
            }
            if (!inputStr.matches(SCORE_REGEX)) {  //  2. 获取输入，正则（SCORE_REGEX)判断，不符合就提示并重新输入
                System.out.println(INPUT_IS_INVALID_TIP);
            } else {
                inputtedNum = Double.parseDouble(inputStr);
                if (inputtedNum < 0 || inputtedNum > 5) {  //  3. 判断，小于0拦，大于5拦（0<= score <= 5放行）
                    System.out.println(ERROR_OUT_OF_RANGE_SCORE);
                    continue;
                }
                return inputtedNum;
            }
        }
    }

    /**
     * 获取菜单编号，只接收1-6和 exit，其他无效
     *
     * @param inputStr 调用方法 judgeInput()预处理后返回的字符串
     * @param regex    菜单正则
     * @return 返回菜单编号
     */
    public static int getMenuItemNumber(String inputStr, String regex) {
        //  1. judgeInput()
        //  2. 获取输入，正则判断，不符合就提示并重新输入
        if (!inputStr.matches(regex)) {
            System.out.println(INPUT_IS_INVALID_TIP);
            return SENTINEL_IS_INVALID;
        }
        //  3. 返回菜单编号
        return Integer.parseInt(inputStr);
    }

    /**
     * 预处理键盘输入，各个方法抽取出来的，不抢占原来方法的功能
     *
     * @param in 键盘输入
     * @return ”“、null、原串
     */
    public static String judgeInput(Scanner in) {
        String inputStr = in.nextLine().strip();
        if (inputStr.isBlank()) {
            return "";
        }
        if (EXIT_KEY_WORD.equalsIgnoreCase(inputStr)) {
            return null;
        }
        return inputStr;
    }
}

▼
/**
复制代码
 *
 * day29:定义Worker类（姓名/工种/工龄/评分），创建2个师傅对象并打印信息。
 * day30:给Worker加3种构造：无参/姓名+工种/全字段，分别创建对象验证；用this区分同名参数
 * day31：给Worker加static计数器count，每创建一个对象+1，打印当前平台注册师傅总数
 * day32：Worker字段全改private；setWorkYears里校验工龄不能<0（负数就置0或抛提示），setScore校验0-5分
 * day33：师傅管理小程序：Worker数组容量10，支持添加、按名字查找、打印全部（遍历调用toString前先自己拼信息）
 * day34：在Day5基础上加：按工种筛选、按评分排序、统计平均工龄，全部封装成方法
 * day35：默写Worker类（封装+构造器+计数器版）
 *
 */

class Worker34 {
    private String name;
    private String jobType;
    private int workYear;
    private double score;

    public Worker34(){this(null,null,0,0.0);}
    public Worker34(String name, String jobType){
        this(name, jobType, 0, 0.0);
    }
    public Worker34(String name, String jobType, int workYear, double score){
        this.setName(name);
        this.setJobType(jobType);
        this.setWorkYear(workYear);
        this.setScore(score);
    }

    public void setName(String name){
        this.name = name;
    }
    public void setJobType(String jobType){
        this.jobType = jobType;
    }
    public void setWorkYear(int workYear){
        if (workYear < 0){
            System.out.println("工龄不能小于0，已置0");
            this.workYear = 0;
        }else{
            this.workYear = workYear;
        }
    }
    public void setScore(double score){
        if (!(score >= 0 && score <=5)){
            System.out.println("评分不能小于0或大于5，已置0");
            this.score = 0;
        }else{
            this.score = score;
        }
    }

    public String getName(){
        return this.name;
    }
    public String getJobType(){
        return this.jobType;
    }
    public int getWorkYear(){
        return this.workYear;
    }
    public double getScore(){
        return this.score;
    }

    @Override
    public String toString(){
        return ("姓名：" + this.getName() + "，工种：" + this.getJobType() + "，工龄：" + this.getWorkYear() + "，评分：" + this.getScore());
    }
}
Java
0个评论
全部评论
点击登录，快来和大家讨论吧～
表情
图片
暂无评论
鱼友0258
鱼友0258
等级vip
内容推荐
更多
AI Coding 已经改变开发方式了，程序员到底还该学什么？
17
Make it right, Make it work, Make it better, Make it best
3
一条告警的 10 秒：从 -5 dB 到"已处理"
3
先有企业级代码思维（代码写健壮），再有企业级代码
2
来一个企业级思维骨架
2
作者分享
更多
来一个企业级思维骨架
2
先有企业级代码思维（代码写健壮），再有企业级代码
2
Make it right, Make it work, Make it better, Make it best
3
清爽的main()结构
3
练习即生产，让正确的用法成为唯一的用法
2
下载 APP