栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

联想词+java+redis

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

联想词+java+redis

因为在网上百度出来的都不咋好用所以自己写了一个,记录一下

主要做法是将自己已有可搜索内容list存储到redis里面,主要包含可搜索内容首字母数组,和可搜索内容全拼数组,然后将输入的字符串转成拼音小写数组,进行比对。

 有用到的包是拼音转化:pinyin4j-2.5.0.jar

下面是实现代码

pom.xml 中央库可能找不到 下载到本地 或者传到私服


        2.5.0


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

pojo 载体类

@Data
public class Search {

    //应用名称
    private String applyName;

    //全小写
    private String lowercase;

    //首字母
    private String initials;

    //频率
    private long sort;


}

 

搜索方法  setSearch是存储可搜索内容  getSearch是获取内容  自己新建类放

 @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;
    }


    
    @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;
    }

    
    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;




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;


public class PinYin4JUtils {
    
    public static String[] stringToPinyin(String src) {
        return stringToPinyin(src, false, null);
    }

    
    public static String[] stringToPinyin(String src, String separator) {
        return stringToPinyin(src, true, separator);
    }

    
    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;
    }

    
    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();
    }

    
    public static String hanziToPinyin(String hanzi) {
        return hanziToPinyin(hanzi, " ");
    }

    
    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;
    }

    
    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();
    }

    
    public static String stringArrayToString(String[] str) {
        return stringArrayToString(str, "");
    }

    
    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();
    }

    
    public static String charArrayToString(char[] ch) {
        return charArrayToString(ch, " ");
    }

    
    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;
    }

    
    public static char[] getHeadByChar(char src) {
        return getHeadByChar(src, true);
    }

    
    public static String[] getHeadByString(String src) {
        return getHeadByString(src, true);
    }

    
    public static String[] getHeadByString(String src, boolean isCapital) {
        return getHeadByString(src, isCapital, null);
    }

    
    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, ",")));
    }
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/973657.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号