Java 为什么Lucene不返回基于全词匹配的结果？

我正在使用Lucene将关键字与应用程序中的单词列表进行匹配。整个过程是自动化的，没有任何人为干预。从Lucene返回的结果列表中选择最匹配的结果（得分最高的结果）

下面的代码演示了上述功能，结果打印在控制台上

问题：

问题是lucene搜索关键字（要搜索的单词）并给出一个部分匹配关键字的单词。另一方面，完全匹配的结果也存在，并且没有排在第一位

例如，如果我有lucene RAM索引，其中包含单词“Test”和“Test Engineer”。如果我想在索引中搜索'AB4_Test Eng_AA0XY11'，那么结果将是

测试
测试工程师

虽然“AB4_测试英语AA0XY11”中的英语与工程师匹配（这就是为什么它被列在结果中）。但它并没有占据榜首的位置。我想优化我的解决方案，使“测试工程师”处于首位，因为它是考虑整个关键字的最佳匹配。有人能帮我解决这个问题吗

public class LuceneTest {

private static void search(Set<String> keywords) {

    StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_36);
    try {
        // 1. create the index
        Directory luceneIndex = buildLuceneIndex(analyzer);

        int hitsPerPage = 5;
        IndexReader reader = IndexReader.open(luceneIndex);

        for(String keyword : keywords) {

            // Create query string. replace all underscore, hyphen, comma, ( , ), {, }, . with plus sign
            StringBuilder querystr = new StringBuilder(128);
            String [] splitName = keyword.split("[\\-_,/(){}:. ]");

            // After tokenizing also add plus sign between each camel case word. 
            for (String token : splitName) {
                querystr.append(token + "+");
            }

            // 3. search
            IndexSearcher searcher = new IndexSearcher(reader);
            TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, true);

            Query q = new QueryParser(Version.LUCENE_36, "name", analyzer).parse(querystr.toString());
            searcher.search(q, collector);
            ScoreDoc[] hits = collector.topDocs().scoreDocs;

            System.out.println();
            System.out.println(keyword);
            System.out.println("----------------------");
            for (ScoreDoc scoreDoc : hits) {
                Document d = searcher.doc(scoreDoc.doc);
                System.out.println("Found " + d.get("id") +  " : " + d.get("name"));
            }

            // searcher can only be closed when there
            searcher.close();
        }

    }catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 
 */
private static Directory buildLuceneIndex(Analyzer analyzer) throws CorruptIndexException, LockObtainFailedException, IOException{

    Map<Integer, String> map = new HashMap<Integer, String>();
    map.put(1, "Test Engineer");
    map.put(2, "Test");

    Directory index = new RAMDirectory();
    IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_36, analyzer);

    // 1. create the index
    IndexWriter w = new IndexWriter(index, config);
    for (Map.Entry<Integer, String> entry : map.entrySet()) {
        try {
            Document doc = new Document();
            doc.add(new Field("id", entry.getKey().toString(), Field.Store.YES, Field.Index.ANALYZED));
            doc.add(new Field("name", entry.getValue() , Field.Store.YES, Field.Index.ANALYZED));
            w.addDocument(doc);

        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    w.close();

    return index;
}


public static void main(String[] args) {

    Set<String> list = new TreeSet<String>();

    list.add("AB4_Test Eng_AA0XY11");
    list.add("AB4_Test Engineer_AA0XY11");

    search(list);
}
}

公共类LuceNet{
专用静态无效搜索（设置关键字）{
StandardAnalyzer=新的StandardAnalyzer（版本.LUCENE_36）；
试一试{
//1.创建索引
目录luceneIndex=buildLuceneIndex（分析器）；
int hitsPerPage=5；
IndexReader=IndexReader.open（luceneIndex）；
for（字符串关键字：关键字）{
//创建查询字符串。用加号替换所有下划线、连字符、逗号、（，）、{、}、
StringBuilder querystr=新的StringBuilder（128）；
字符串[]splitName=关键字.split（[\\-\\，/（）{}:.]'）；
//在标记化之后，还要在每个大小写单词之间添加加号。
for（字符串标记：splitName）{
追加（标记+“+”）；
}
//3.搜索
IndexSearcher search=新的IndexSearcher（阅读器）；
TopScoreDocCollector=TopScoreDocCollector.create（hitsPerPage，true）；
Query q=new QueryParser（Version.LUCENE_36，“name”，analyzer）.parse（querystr.toString（））；
搜索者。搜索（q，收集器）；
ScoreDoc[]hits=collector.topDocs（）.scoreDocs；
System.out.println（）；
System.out.println（关键字）；
System.out.println（“-------------------------”）；
对于（ScoreDoc ScoreDoc:hits）{
文档d=searcher.doc（scoreDoc.doc）；
System.out.println（“Found”+d.get（“id”）+：“+d.get（“name”））；
}
//搜索程序只能在存在时关闭
searcher.close（）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
/**
* 
*/
私有静态目录buildLuceneIndex（Analyzer Analyzer）引发CorruptIndexException、LockOcctainFailedException、IOException{
Map Map=newhashmap（）；
地图放置（1，“测试工程师”）；
地图放置（2，“测试”）；
目录索引=新的RAMDirectory（）；
IndexWriterConfig配置=新的IndexWriterConfig（Version.LUCENE_36，analyzer）；
//1.创建索引
IndexWriter w=新的IndexWriter（索引，配置）；
对于（Map.Entry:Map.entrySet（））{
试一试{
单据单据=新单据（）；
添加（新字段（“id”，entry.getKey（）.toString（），Field.Store.YES，Field.Index.analysis））；
添加（新字段（“名称”，entry.getValue（），Field.Store.YES，Field.Index.analysis））；
w、 添加文档（doc）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
w、 close（）；
收益指数；
}
公共静态void main（字符串[]args）{
设置列表=新树集（）；
列表。添加（“AB4测试工程AA0XY11”）；
列表。添加（“AB4_测试工程师_AA0XY11”）；
搜索（列表）；
}
}

您可以查看，以了解如何强制搜索

测试工程师

基本上，使用诸如

 AB4_Test AND Eng_AA0XY11

可以，尽管我不确定。上面链接指向的页面非常简洁，您将能够快速找到满足您需求的查询。
您可以查看以了解如何强制搜索
测试工程师

基本上，使用诸如

 AB4_Test AND Eng_AA0XY11

可以，尽管我不确定。上面链接指向的页面非常简洁，您将能够快速找到满足您需求的查询。
如果这两个结果（测试、测试工程师）具有相同的排名分数，那么您将按照它们出现的顺序看到它们。
你应该尝试使用长度过滤器，同时增加术语，然后也许你可以想出解决方案

另见：
如果这两个结果（测试、测试工程师）具有相同的排名分数，那么您将按照它们出现的顺序看到它们。
你应该尝试使用长度过滤器，同时增加术语，然后也许你可以想出解决方案

另见：
谢谢。这是我已经阅读并尝试过的一般性帮助，但没有得到我想要的结果。你能给我一些提示吗？这个问题的具体提示/解决方案？谢谢。这是我已经阅读并尝试过的一般性帮助，但没有得到我想要的结果。你能给我一些关于这个问题的具体提示/解决方案吗？