输入字符联想匹配算法

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class App {
    private static Map<String,List<String>> collegeData = new HashMap<String,List<String>>();
    public static void main(String[] args) throws Exception {
        initData(); //获取联想数据字典collegeData
        //System.out.println("Hello, World!"+collegeData.toString());
        associateStr("tech");
    }
    /**
     * 不考虑字母在中间的情况
     * 1 字符串匹配算法，匹配相同的字符 匹配成功返回true，打上key的标记
     * 2 输入多个字符串的时候 根据空格字符(\u0020)分割，走单个匹配规则
     * 3 组织联想字符串
     * 考虑算法 暴力匹配
     * 根据用户输入字符串长度，直接截取匹配对应数组字符串的值，相同则匹配通过，数组字段不满足条件时，直接跳过
     */
    public static void associateStr(String inputContent){
        String [] arrs = inputContent.split("\u0020");
        int arrsLen = arrs.length; //数组长度
        Map<String,Integer> resultStr = new HashMap<String,Integer>();
        for(String msg : arrs){
            int len = msg.length();
            //取出所有key
            Set<String> keys=collegeData.keySet();
            //根据key获取里面的value
            for(String key : keys){
                List<String> values = collegeData.get(key);
                int keyShowNums = 1;
                boolean flag = false; //是否第一次匹配标记
                for(String val : values){
                    if(val.length()<len){
                        continue;
                    }else{
                        val = val.substring(0, len);
                        if(val.equals(msg)){
                            if(arrsLen==1){
                                resultStr.put(key,keyShowNums++);
                                break; //结束当前循环
                            }else{
                                if(flag){
                                    resultStr.replace(key, keyShowNums-1, keyShowNums);
                                }else{
                                    resultStr.put(key,keyShowNums++);
                                }
                            }
                            flag = true;
                        }
                    }
                }
            }
        }
        //统计出现的次数优先返回输出次数多的
        if(arrsLen==1){
            System.out.println("提示内容"+resultStr.keySet());
        }else{
            //输出map集合里次数最高大的,不考虑次数重复的情况
            Map<String, Integer> sortMap = sortMap(resultStr);
            Set<String> keys=sortMap.keySet();
            for(String key :keys){
                System.out.println("提示内容"+key);
                return;
            }
        }
        
    }
    /**
     * map集合排序
     * @param map
     * @return
     */
    public static Map<String, Integer> sortMap(Map<String, Integer> map) {
        //利用Map的entrySet方法，转化为list进行排序
        List<Map.Entry<String, Integer>> entryList = new ArrayList<>(map.entrySet());
        //利用Collections的sort方法对list排序
        Collections.sort(entryList, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                //倒序排列，正序序反过来
                return o2.getValue() - o1.getValue();
            }
        });
        //遍历排序好的list，一定要放进LinkedHashMap，因为只有LinkedHashMap是根据插入顺序进行存储
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
        for (Map.Entry<String,Integer> e : entryList
        ) {
            linkedHashMap.put(e.getKey(),e.getValue());
        }
        return linkedHashMap;
    }

}