联想词+java+redis

因为百度在网上不好用，所以我写了一个，记录下来

主要做法是搜索自己已经可搜索的内容list存储到redis主要包括可搜索内容首字母数组和可搜索内容全拼数组，然后将输入的字符串转换为拼音小写数组进行比较。

有用的包是拼音转换：pinyin4j-2.5.0.jar

         2.5.0               net.sourceforge.pinyin4j             pinyin4j             ${pinyin4j.version}  

@Data public class Search {      //应用名称     private String applyName;      //全小写     private String lowercase;      //首字母     private String initials;      //频率     private long sort;   }

 @Override     public List>  searchCache(String searchVal) {         List> list=new ArrayList<>();         //先分词         List stringList=participle(searchVal,new ArrayList<>());         if(stringList.size()==0){             return list;         }         Collection keys = redisCache.keys(Constants.SEARCH_CACHE_KEY   "*");         keys=searchSet(keys);         for (String key:keys) {              String sKey= redisCache.getCacheObject(key);              Search search= redisCache.getCacheObject(sKey);             for (String str:stringList) {                if(hasRepeat(str,search.getInitials())>0||hasRepeat(str,search.getLowercase())>0){                    Map map=new HashMap<>();                    map.put("applyName",search.getApplyName());                    map.put("sort",search.getSort());                    list.add(map);                    search.setSort(search.getSort() 1L);                    redisCache.setCacheObject(sKey,search);                    ///加一个队列 //                   AsyncManager.me().execute(AppAsyncFactory.saveVehicle(upi));                    break;                }             }         }         return list;     }       /**      * 可存可搜索数据      * @param keys      * @return      */     @Override     public Collection searchSet(Collection keys){         if(null!=keys&&keys.size()>0){             return keys;         }                 ///自定义获取可搜索内容list         List list=langjfService.list(queryWrapper);            if(list.size()>0){             keys=new ArrayList<>();             for (AA  aa:list) {                 String key=Constants.SEARCH_CACHE_KEY   aa.getId();                 String md5Key=MD5Util.MD5(key);                 keys.add(md5Key);                 Search search= null;                 try {                     search = redisCache.getCacheObject(md5Key);                 } catch (Exception e) {                     redisCache.deleteObject(key);                 }                 if(null==search){                      search=new Search();                      search.setName(aa.getName());                      search.setSort(0);                      search.setInitials(Arrays.toString(PinYin4JUtils.getHeadByString(shopApply.getApplyName(),false)));                      search.setLowercase(Arrays.toString(PinYin4JUtils.stringToPinyin(shopApply.getApplyName(), true, ",")));                  }                   search.setSort(search.getSort() 1);                 redisCache.setCacheObject(Constants.SEARCH_CACHE_KEY   shopApply.getId(),md5Key);                 redisCache.setCacheObject(md5Key,search);              }         }   return keys;     }        /**      * 分词      */     public List participle(String searchVal,List list){         if(StringUtils.isEmpty(searchVal)){             return list;         }         char[] array=searchVal.toCharArray();         list.add(Arrays.toString(PinYin4JUtils.getHeadByString(searchVal,false)));         list.add(Arrays.toString(PinYin4JUtils.stringToPinyin(searchVal, true, ",")));         return list;     }       public static boolean isChineseChar(String str){          boolean temp = false;          Pattern p= Pattern.compile("[\u4e00-\u9fa5]");          Matcher m=p.matcher(str);          if(m.find()){             temp =  true;         }         return temp;     }      /**      *获得两个数组的最佳匹配度      * @param str1 匹配值      * @param str2 查询区      * @return      */     public static int hasRepeat(String str1,String str2){         int a=0;       String[]  str1s= str1.substring(1,str1.length()-1).split(,");
      String[]  str2s= str2.substring(1,str2.length()-1).split(",");
      //2/3匹配为可用匹配
        double count=Math.ceil((str1s.length/Double.valueOf(3))*2);
        //跳点 计数出现几次
        int    jumpPoint=0;
        for (String str:   str1s) {
            if(StringUtils.isEmpty(str)){
                continue;
            }
            boolean isTrue=false;
            for (String str2temp:  str2s) {
                if(StringUtils.isEmpty(str2temp)){
                    continue;
                }
                if(str.trim().equals(str2temp.trim())||
                        str.trim().indexOf(str2temp.trim())!=-1||
                        str2temp.trim().indexOf(str.trim())!=-1){
                    a++;
                    isTrue=true;
                }

            }
            if(isTrue){jumpPoint++;};
        }
        //出现次数大于2/3 并且每个字符都跳动过
        if(a>=count&&jumpPoint==str1s.length){
            return a;
        }
        a=0;
        return a;
    }

顺便贴一个工具类，别人的挺全。文章地址确实是忘了~~~~~~ 

package com.langjf.web.utils;

/**
 * @Author:langjf
 * @Date: 2022/6/10
 * @Desc
 */


import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

import java.util.Arrays;
import java.util.Locale;

/**
 * @create 2019-12-18 17:25
 * PinYin4j工具类
 */
public class PinYin4JUtils {
    /**
     * 将字符串转换成拼音数组
     *
     * @param src 字符串
     * @return
     */
    public static String[] stringToPinyin(String src) {
        return stringToPinyin(src, false, null);
    }

    /**
     * 将字符串转换成拼音数组
     *
     * @param src       字符串
     * @param separator 多音字拼音之间的分隔符
     * @return
     */
    public static String[] stringToPinyin(String src, String separator) {
        return stringToPinyin(src, true, separator);
    }

    /**
     * 将字符串转换成拼音数组
     *
     * @param src         字符串
     * @param isPolyphone 是否查出多音字的所有拼音
     * @param separator   多音字拼音之间的分隔符
     * @return
     */
    public static String[] stringToPinyin(String src, boolean isPolyphone, String separator) {
        // 判断字符串是否为空
        if (StringUtils.isBlank(src)) {
            return null;
        }

        char[] srcChar = src.toCharArray();
        int srcCount = srcChar.length;
        String[] srcStr = new String[srcCount];

        for (int i = 0; i < srcCount; i++) {
            srcStr[i] = charToPinyin(srcChar[i], isPolyphone, separator);
        }
        return srcStr;
    }

    /**
     * 将单个字符转换成拼音
     *
     * @param src         被转换的字符
     * @param isPolyphone 是否查出多音字的所有拼音
     * @param separator   多音字拼音之间的分隔符
     * @return
     */
    public static String charToPinyin(char src, boolean isPolyphone, String separator) {
        // 创建汉语拼音处理类
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        // 输出设置，大小写，音标方式
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);

        StringBuffer tempPinying = new StringBuffer();

        // 如果是中文
        if (src > 128) {
            try {
                // 转换得出结果
                String[] strs = PinyinHelper.toHanyuPinyinStringArray(src, defaultFormat);

                // 是否查出多音字，默认是查出多音字的第一个字符
                if (isPolyphone && null != separator) {
                    for (int i = 0; i < strs.length; i++) {
                        tempPinying.append(strs[i]);
                        if (strs.length != (i + 1)) {
                            // 多音字之间用特殊符号间隔起来
                            tempPinying.append(separator);
                        }
                    }
                } else {
                    tempPinying.append(strs[0]);
                }

            } catch (BadHanyuPinyinOutputFormatCombination e) {
                e.printStackTrace();
            }
        } else {
            tempPinying.append(Character.toLowerCase(src));
        }

        return tempPinying.toString();
    }

    /**
     * 将汉字转换成拼音
     *
     * @param hanzi
     * @return
     */
    public static String hanziToPinyin(String hanzi) {
        return hanziToPinyin(hanzi, " ");
    }

    /**
     * 将汉字转换成拼音
     *
     * @param hanzi     汉字
     * @param separator 分隔符
     * @return
     */
    public static String hanziToPinyin(String hanzi, String separator) {
        // 创建汉语拼音处理类
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        // 输出设置，大小写，音标方式
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);

        String pinyingStr = "";
        try {
            pinyingStr = PinyinHelper.toHanyuPinyinString(hanzi, defaultFormat, separator);
        } catch (BadHanyuPinyinOutputFormatCombination e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return pinyingStr;
    }

    /**
     * 将字符串数组转换成字符串
     *
     * @param str
     * @param separator 各个字符串之间的分隔符
     * @return
     */
    public static String stringArrayToString(String[] str, String separator) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < str.length; i++) {
            sb.append(str[i]);
            if (str.length != (i + 1)) {
                sb.append(separator);
            }
        }
        return sb.toString();
    }

    /**
     * 简单的将各个字符数组之间连接起来
     *
     * @param str
     * @return
     */
    public static String stringArrayToString(String[] str) {
        return stringArrayToString(str, "");
    }

    /**
     * 将字符数组转换成字符串
     *
     * @param ch        字符数组
     * @param separator 各个字符串之间的分隔符
     * @return
     */
    public static String charArrayToString(char[] ch, String separator) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < ch.length; i++) {
            sb.append(ch[i]);
            if (ch.length != (i + 1)) {
                sb.append(separator);
            }
        }
        return sb.toString();
    }

    /**
     * 将字符数组转换成字符串
     *
     * @param ch 字符数组
     * @return
     */
    public static String charArrayToString(char[] ch) {
        return charArrayToString(ch, " ");
    }

    /**
     * 取汉字的首字母
     *
     * @param src
     * @param isCapital 是否是大写
     * @return
     */
    public static char[] getHeadByChar(char src, boolean isCapital) {
        // 如果不是汉字直接返回
        if (src <= 128) {
            return new char[]{(isCapital)?Character.toUpperCase(src):Character.toLowerCase(src)};
        }
        // 获取所有的拼音
        String[] pinyingStr = PinyinHelper.toHanyuPinyinStringArray(src);

        // 创建返回对象
        int polyphoneSize = pinyingStr.length;
        char[] headChars = new char[polyphoneSize];
        int i = 0;
        // 截取首字符
        for (String s : pinyingStr) {
            char headChar = s.charAt(0);
            // 首字母是否大写，默认是小写
            if (isCapital) {
                headChars[i] = Character.toUpperCase(headChar);
            } else {
                headChars[i] = headChar;
            }
            i++;
        }

        return headChars;
    }

    /**
     * 取汉字的首字母(默认是大写)
     *
     * @param src
     * @return
     */
    public static char[] getHeadByChar(char src) {
        return getHeadByChar(src, true);
    }

    /**
     * 查找字符串首字母
     *
     * @param src
     * @return
     */
    public static String[] getHeadByString(String src) {
        return getHeadByString(src, true);
    }

    /**
     * 查找字符串首字母
     *
     * @param src
     * @param isCapital 是否大写
     * @return
     */
    public static String[] getHeadByString(String src, boolean isCapital) {
        return getHeadByString(src, isCapital, null);
    }

    /**
     * 查找字符串首字母
     *
     * @param src       汉字字符串
     * @param isCapital 是否大写
     * @param separator 分隔符
     * @return
     */
    public static String[] getHeadByString(String src, boolean isCapital, String separator) {
        char[] chars = src.toCharArray();
        String[] headString = new String[chars.length];
        int i = 0;
        for (char ch : chars) {

            char[] chs = getHeadByChar(ch, isCapital);
            StringBuffer sb = new StringBuffer();
            if (null != separator) {
                int j = 1;

                for (char ch1 : chs) {
                    sb.append(ch1);
                    if (j != chs.length) {
                        sb.append(separator);
                    }
                    j++;
                }
            } else {
                sb.append(chs[0]);
            }
            headString[i] = sb.toString();
            i++;
        }
        return headString;
    }

    public static void main(String[] args) {
        String s1 = "lz啊哈哈";
        System.out.println(s1.toLowerCase(Locale.ROOT));
        String[] headArray = getHeadByString(s1,false); 
        System.out.println(Arrays.toString(headArray));

        String s2 = "Zzx长";
        System.out.println(Arrays.toString(stringToPinyin(s2, true, ",")));

        String s3 = "长";
        System.out.println(Arrays.toString(stringToPinyin(s3, true, ",")));
    }
}