java实现中文模糊查询的示例代码

// 文件：core/FuzzySearchService.java
package com.example.fuzzy.core;
import java.util.List;
import java.util.Map;
/**
 * 模糊查询服务接口
 */
public interface FuzzySearchService<T> {
    /**
     * 对内存数据列表进行模糊查询
     * @param dataList 待检索对象列表
     * @param fieldExtractor 字段提取器，返回待匹配字符串
     * @param keyword 用户输入关键词
     * @param topK 返回前 K 名排序结果
     * @return 匹配结果列表
     */
    List<T> searchInMemory(List<T> dataList,
                           FieldExtractor<T> fieldExtractor,
                           String keyword,
                           int topK);
 
    /**
     * 对数据库指定表字段进行模糊查询
     * @param tableName 表名
     * @param columnName 列名
     * @param keyword 用户输入关键词
     * @param params JDBC 参数（如分页）
     * @return 查询结果列表，每条记录为列名→值的 Map
     */
    List<Map<String, Object>> searchInDatabase(String tableName,
                                               String columnName,
                                               String keyword,
                                               Map<String, Object> params);
}
 
// 文件：core/FieldExtractor.java
package com.example.fuzzy.core;
/**
 * 字段提取器，用于从对象中获取待匹配字符串
 */
public interface FieldExtractor<T> {
    String extract(T obj);
}
 
// 文件：pinyin/PinyinConverter.java
package com.example.fuzzy.pinyin;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.*;
/**
 * 拼音转换工具
 */
public class PinyinConverter {
    private static HanyuPinyinOutputFormat fmt = new HanyuPinyinOutputFormat();
    static {
        fmt.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        fmt.setVCharType(HanyuPinyinVCharType.WITH_V);
    }
    /** 获取字符串全拼，如“北京”→“beijing” */
    public static String toPinyin(String chinese) throws BadHanyuPinyinOutputFormatCombination {
        StringBuilder sb = new StringBuilder();
        for (char c : chinese.toCharArray()) {
            if (Character.toString(c).matches("[\\u4E00-\\u9FA5]+")) {
                String[] arr = PinyinHelper.toHanyuPinyinStringArray(c, fmt);
                sb.append(arr[0]);
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
    /** 获取拼音首字母，如“北京”→“bj” */
    public static String toPinyinInitials(String chinese) throws BadHanyuPinyinOutputFormatCombination {
        StringBuilder sb = new StringBuilder();
        for (char c : chinese.toCharArray()) {
            if (Character.toString(c).matches("[\\u4E00-\\u9FA5]+")) {
                String[] arr = PinyinHelper.toHanyuPinyinStringArray(c, fmt);
                sb.append(arr[0].charAt(0));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}
 
// 文件：distance/LevenshteinDistance.java
package com.example.fuzzy.distance;
/**
 * 编辑距离算法实现
 */
public class LevenshteinDistance {
    public static int compute(String s1, String s2) {
        int n = s1.length(), m = s2.length();
        int[][] dp = new int[n+1][m+1];
        for (int i = 0; i <= n; i++) dp[i][0] = i;
        for (int j = 0; j <= m; j++) dp[0][j] = j;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                int cost = s1.charAt(i-1) == s2.charAt(j-1) ? 0 : 1;
                dp[i][j] = Math.min(Math.min(dp[i-1][j] + 1, dp[i][j-1] + 1),
                                    dp[i-1][j-1] + cost);
            }
        }
        return dp[n][m];
    }
    /** 归一化相似度 = 1 - distance/maxLen */
    public static double similarity(String s1, String s2) {
        int dist = compute(s1, s2);
        int max = Math.max(s1.length(), s2.length());
        return max == 0 ? 1.0 : 1.0 - (double) dist / max;
    }
}
 
// 文件：core/impl/InMemorySearchServiceImpl.java
package com.example.fuzzy.core.impl;
import com.example.fuzzy.core.*;
import com.example.fuzzy.distance.LevenshteinDistance;
import com.example.fuzzy.pinyin.PinyinConverter;
import java.util.*;
/**
 * 内存模糊查询实现
 */
public class InMemorySearchServiceImpl<T> implements FuzzySearchService<T> {
    @Override
    public List<T> searchInMemory(List<T> dataList,
                                  FieldExtractor<T> fieldExtractor,
                                  String keyword,
                                  int topK) {
        List<Result<T>> results = new ArrayList<>();
        // 预处理关键词
        String kw = preprocess(keyword);
        String kwPinyin = toPinyinSafe(kw);
        String kwInitials = toInitialsSafe(kw);
        for (T item : dataList) {
            String text = fieldExtractor.extract(item);
            String txt = preprocess(text);
            // 原文相似度
            double simText = LevenshteinDistance.similarity(txt, kw);
            // 拼音相似度
            double simPin = LevenshteinDistance.similarity(toPinyinSafe(txt), kwPinyin);
            // 首字母相似度
            double simInit = LevenshteinDistance.similarity(toInitialsSafe(txt), kwInitials);
            double score = Math.max(Math.max(simText, simPin), simInit);
            if (score > 0.5) {
                results.add(new Result<>(item, score));
            }
        }
        // 排序并截取 topK
        results.sort((a, b) -> Double.compare(b.score, a.score));
        List<T> top = new ArrayList<>();
        for (int i = 0; i < Math.min(topK, results.size()); i++) {
            top.add(results.get(i).data);
        }
        return top;
    }
    private String preprocess(String s) {
        return s == null ? "" : s.trim().toLowerCase();
    }
    private String toPinyinSafe(String s) {
        try { return PinyinConverter.toPinyin(s); }
        catch (Exception e) { return s; }
    }
    private String toInitialsSafe(String s) {
        try { return PinyinConverter.toPinyinInitials(s); }
        catch (Exception e) { return s; }
    }
 
    @Override
    public List<Map<String, Object>> searchInDatabase(String tableName, String columnName, String keyword, Map<String, Object> params) {
        // 简化示例：只演示 SQL 构造
        String sql = "SELECT * FROM " + tableName +
                     " WHERE " + columnName + " LIKE ? " +
                     "ORDER BY LENGTH(" + columnName + ") ASC " +
                     "LIMIT ?, ?";
        // 参数：%keyword%, offset, pageSize
        // JDBC 执行略
        return Collections.emptyList();
    }
}
 
// 辅助类
class Result<T> {
    T data;
    double score;
    Result(T data, double score) { this.data = data; this.score = score; }
}