Java实现配置文件恢复 匹配

题目描述

有6条配置命令，它们执行的结果分别是：

命   令	执   行
reset	reset what
reset board	board fault
board add	where to add
board delet	no board at all
reboot backplane	impossible
backplane abort	install first
he he	unkown command

 注意：he he不是命令。

为了简化输入，方便用户，以“最短唯一匹配原则”匹配：
1、若只输入一字串，则只匹配一个关键字的命令行。例如输入：r，根据该规则，匹配命令reset，执行结果为：reset what；输入：res，根据该规则，匹配命令reset，执行结果为：reset what；
2、若只输入一字串，但本条命令有两个关键字，则匹配失败。例如输入：reb，可以找到命令reboot backpalne，但是该命令有两个关键词，所有匹配失败，执行结果为：unkown command
3、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果仍不唯一，匹配失败。例如输入：r b，找到匹配命令reset board，执行结果为：board fault。

4、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果唯一，匹配成功。例如输入：b a，无法确定是命令board add还是backplane abort，匹配失败。
5、若输入两字串，第一关键字匹配成功，则匹配第二关键字，若无匹配，失败。例如输入：bo a，确定是命令board add，匹配成功。
6、若匹配失败，打印“unkown command”

输入描述:

多行字符串，每行字符串一条命令

输出描述:

执行结果，每条命令输出一行

输入例子:

reset
reset board
board add
board delet
reboot backplane
backplane abort

输出例子:

reset what
board fault
where to add
no board at all
impossible
install first

我的分析：

1、首先判断是一字符还是两字符，这样可以知道是否是  reset串。

2、如果是两字符，首先用split分割串，然后需要去分别匹配已知命令，这里其实需要判断

1）是否只匹配一个命令？ 如果匹配多个命令，那就是unknown

2）是否匹配不到任何命令，那更是unkown了

然后我的代码，写完，一次ac，我还有点儿惶恐..... 但是我觉得代码不够优雅：

import java.util.*;

public class Main{
   	    
    public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
         while (scanner.hasNext()) {
             String s=scanner.nextLine();
              System.out.println(Func(s));
         }
      scanner.close();
       
    }
    
    public static String Func(String s){
   		 String s1="reset";
   		 String s2="reset board";
       String s3="board add";
         String s4="board delete";
         String s5="reboot backplane";
        String s6="backplane abort";
    String reset="reset what";
     String reset_board="board fault";
     String board_add="where to add";
     String board_delete="no board at all";
     String reboot_backplane="impossible";
     String backplane_abort="install first";
    String others="unkown command";
        
        boolean a=s.contains(" ");
        if(a){
            String [] sa = s.split(" ");
            int count=0;
            String result="";
            String [] s22=s2.split(" ");
			String [] s33=s3.split(" ");
            String [] s44=s4.split(" ");
            String [] s55=s5.split(" ");
            String [] s66=s6.split(" ");
            if(s22[0].startsWith(sa[0])&&s22[1].startsWith(sa[1])){
                result=reset_board;
                count++;
            }else if(s33[0].startsWith(sa[0])&&s33[1].startsWith(sa[1])){
                result=board_add;
                count++;
            }else if(s44[0].startsWith(sa[0])&&s44[1].startsWith(sa[1])){
                result=board_delete;
                count++;
            }else if(s55[0].startsWith(sa[0])&&s55[1].startsWith(sa[1])){
                result=reboot_backplane;
                count++;
            }else if(s66[0].startsWith(sa[0])&&s66[1].startsWith(sa[1])){
                result=backplane_abort;
                count++;
            }
            
            if(count==1){
                return result;
            }else{
                return others;
            }
            
            
        }else{
            
            if(s1.startsWith(s)){
                return reset;
            }else
                return others;
        }
        
        
    }
    
    
    
    
}

不够优雅主要是太多太多String的定义了，代码看着很杂乱，而且写的重复性很高，

来看看大神是怎么做的吧？

大神为什么不用startsWith？ 我觉得很方便啊

不过还是学到了，应该用HashMap去存String，确实，这样看起来代码能够更加简洁一些，键值对啊！！为什么不用HashMap呢，我个猪脑子哎、

链接：https://www.nowcoder.com/questionTerminal/ca6ac6ef9538419abf6f883f7d6f6ee5
来源：牛客网

import java.util.*;
 
public class Main {
     
    public static boolean isMatch(String src, String des){
        char[] c1 = src.toCharArray();
        char[] c2 = des.toCharArray();
        int i = 0;
        while(i < c1.length && i < c2.length){
            if(c1[i] == c2[i])
                i++;
            else
                break;
        }
        if(i == c1.length)
            return true;
        else
            return false;
    }
     
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        HashMap<String, String> hMap = new HashMap<>();
        hMap.put("reset", "reset what");
        hMap.put("reset board", "board fault");
        hMap.put("board add", "where to add");
        hMap.put("board delet", "no board at all");
        hMap.put("reboot backplane", "impossible");
        hMap.put("backplane abort", "install first");
        while (scanner.hasNext()) {
            String[] strs = scanner.nextLine().split(" ");
            int count = 0; // 记录匹配个数
            Set<String> set = hMap.keySet();
            String key = "";
            for(String s : set){
                String[] temps = s.split(" ");
                if(temps.length == strs.length){
                    int i = 0;
                    while(i < temps.length){
                        if(isMatch(strs[i], temps[i]))
                            i++;
                        else
                            break;
                    }
                    if(i == temps.length){ // 找到匹配
                        key = s;
                        count++;
                    }                       
                }
            }
            if(count != 1)
                System.out.println("unkown command");
            else
                System.out.println(hMap.get(key));
                 
        }
        scanner.close();
    }
}