Lucene中的各种Query实例

最新推荐文章于 2025-04-29 17:07:46 发布
最新推荐文章于 2025-04-29 17:07:46 发布
阅读量4.1k 收藏 1
点赞数
文章标签： query lucene import exception null 文档
本文介绍Lucene中的多种搜索技巧，包括精确匹配、模糊匹配、范围搜索等，通过具体实例演示了如何灵活运用这些技巧来提高搜索效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

(1):TernQuery

/*
 * Created on 2006-3-11
 */
package  ch11;

 import  org.apache.lucene.analysis.standard.StandardAnalyzer;
 import  org.apache.lucene.document.Document;
 import  org.apache.lucene.document.Field;
 import  org.apache.lucene.index.IndexWriter;
 import  org.apache.lucene.index.Term;
 import  org.apache.lucene.search.Hits;
 import  org.apache.lucene.search.IndexSearcher;
 import  org.apache.lucene.search.Query;
 import  org.apache.lucene.search.TermQuery;

 public   class  TermQueryTest
 {
  public static void main(String[] args) throws Exception
  {
    Document doc1 = new Document();
    doc1.add(Field.Text("name", "word1 word2 word3"));
    doc1.add(Field.Keyword("title", "doc1"));

    IndexWriter writer = new IndexWriter("c:/java/index", new StandardAnalyzer(), true);
    writer.addDocument(doc1);
    writer.close();

    Query query = null;
    Hits hits = null;
    
    IndexSearcher searcher = new IndexSearcher("c:/java/index");
    
    query = new TermQuery(new Term("name","word1"));
    hits = searcher.search(query);
    printResult(hits, "word1");
    
    query = new TermQuery(new Term("title","doc1"));
    hits = searcher.search(query);
    printResult(hits, "doc1");

  }

  public static void printResult(Hits hits, String key) throws Exception
  {
    System.out.println("查找 "" + key + "" :");
    if (hits != null)
    {
      if (hits.length() == 0)
      {
        System.out.println("没有找到任何结果");
      }
      else
      {
        System.out.println("找到" + hits.length() + "个结果");
        for (int i = 0; i < hits.length(); i++)
        {
          Document d = hits.doc(i);
          String dname = d.get("title");
          System.out.print(dname + "   ");
        }
        System.out.println();
        System.out.println();
      }
    }
  }
}

运行结果：
C:/>java TermQueryTest
查找 "word1" :
找到1个结果
doc1

查找 "doc1" :
找到1个结果
doc1

(2):与或搜索

 

/*
 * Created on 2006-3-11
 */
import  org.apache.lucene.analysis.standard.StandardAnalyzer;
 import  org.apache.lucene.document.Document;
 import  org.apache.lucene.document.Field;
 import  org.apache.lucene.index.IndexWriter;
 import  org.apache.lucene.index.Term;
 import  org.apache.lucene.search.BooleanQuery;
 import  org.apache.lucene.search.Hits;
 import  org.apache.lucene.search.IndexSearcher;
 import  org.apache.lucene.search.Query;
 import  org.apache.lucene.search.TermQuery;

 public   class  BooleanQueryTest1
 {
  public static void main (String [] args) throws Exception {
    Document doc1 = new Document();
    doc1.add(Field.Text("name", "word1 word2 word3"));
    doc1.add(Field.Keyword("title", "doc1"));
    
    Document doc2 = new Document();
    doc2.add(Field.Text("name", "word1 word4 word5"));
    doc2.add(Field.Keyword("title", "doc2"));
    
    Document doc3 = new Document();
    doc3.add(Field.Text("name", "word1 word2 word6"));
    doc3.add(Field.Keyword("title", "doc3"));
    
    IndexWriter writer = new IndexWriter("c:/java/index", new StandardAnalyzer(), true);
    writer.addDocument(doc1);
    writer.addDocument(doc2);
    writer.addDocument(doc3);
    writer.close();
    
    Query query1 = null;
    Query query2 = null;
    BooleanQuery query = null;
    Hits hits = null;
    
    IndexSearcher searcher = new IndexSearcher("c:/java/index");
    
    query1 = new TermQuery(new Term("name","word1"));
    query2 = new TermQuery(new Term("name","word2"));
    
    // 构造一个布尔查询
    query = new BooleanQuery();

  // 添加两个子查询，与关系
  //  query.add(query1, true, false);
 //  query.add(query2, true, false);
    
    
    // 添加两个子查询，或关系
    query.add(query1, false, false);
    query.add(query2, false, false);
    
    hits = searcher.search(query);
    printResult(hits, "word1和word2");
    
  }
  
  public static void printResult(Hits hits, String key) throws Exception
  {
    System.out.println("查找 "" + key + "" :");
    if (hits != null)
    {
      if (hits.length() == 0)
      {
        System.out.println("没有找到任何结果");
      }
      else
      {
        System.out.println("找到" + hits.length() + "个结果");
        for (int i = 0; i < hits.length(); i++)
        {
          Document d = hits.doc(i);
          String dname = d.get("title");
          System.out.print(dname + "   ");
        }
        System.out.println();
        System.out.println();
      }
    }
  }
}

运行结果：

C:/>java BooleanQueryTest1
查找 "word1和word2" :
找到3个结果
doc1 doc3 doc2 　

(3):在范围内搜索

import  org.apache.lucene.analysis.standard.StandardAnalyzer;
 import  org.apache.lucene.document.Document;
 import  org.apache.lucene.document.Field;
 import  org.apache.lucene.index.IndexWriter;
 import  org.apache.lucene.index.Term;
 import  org.apache.lucene.search.Hits;
 import  org.apache.lucene.search.IndexSearcher;
 import  org.apache.lucene.search.RangeQuery;

 public   class  RangeQueryTest  {
    public static void main (String [] args) throws Exception {
        Document doc1 = new Document();
        doc1.add(Field.Text("time", "200001"));
        doc1.add(Field.Keyword("title", "doc1"));
        
        Document doc2 = new Document();
        doc2.add(Field.Text("time", "200002"));
        doc2.add(Field.Keyword("title", "doc2"));
        
        Document doc3 = new Document();
        doc3.add(Field.Text("time", "200003"));
        doc3.add(Field.Keyword("title", "doc3"));
        
        Document doc4 = new Document();
        doc4.add(Field.Text("time", "200004"));
        doc4.add(Field.Keyword("title", "doc4"));
        
        Document doc5 = new Document();
        doc5.add(Field.Text("time", "200005"));
        doc5.add(Field.Keyword("title", "doc5"));
        
        IndexWriter writer = new IndexWriter("c:/java/index", new StandardAnalyzer(), true);
        writer.setUseCompoundFile(true);
        writer.addDocument(doc1);
        writer.addDocument(doc2);
        writer.addDocument(doc3);
        writer.addDocument(doc4);
        writer.addDocument(doc5);
        writer.close();
        
        IndexSearcher searcher = new IndexSearcher("c:/java/index");
        Term beginTime = new Term("time","200001");
        Term endTime = new Term("time","200005");
        
        Hits hits = null;
        RangeQuery query = null;
        
        query = new RangeQuery(beginTime, endTime, false);
        hits = searcher.search(query);
        printResult(hits, "从200001到200005的文档，不包括200001和200005");
        
        query = new RangeQuery(beginTime, endTime, true);
        hits = searcher.search(query);
        printResult(hits, "从200001到200005的文档，包括200001和200005");
        
    }
    
    public static void printResult(Hits hits, String key) throws Exception {
        System.out.println("查找 "" + key + "" :");
        if (hits != null) {
            if (hits.length() == 0) {
                System.out.println("没有找到任何结果");
            } else {
                System.out.print("找到");
                for (int i = 0; i < hits.length(); i++) {
                    Document d = hits.doc(i);
                    String dname = d.get("title");
                    System.out.print(dname + "   " );
                }
                System.out.println();
                System.out.println();
            }
        }
    }
}


运行结果：
C:/java>java   RangeQueryTest
查找 "从200001到200005的文档，不包括200001和200005" :
找到doc2   doc3   doc4

查找 "从200001到200005的文档，包括200001和200005" :
找到doc1 doc2 doc3 doc4 doc5

(4):使用前缀搜索

import  org.apache.lucene.analysis.standard.StandardAnalyzer;
 import  org.apache.lucene.document.Document;
 import  org.apache.lucene.document.Field;
 import  org.apache.lucene.index.IndexWriter;
 import  org.apache.lucene.index.Term;
 import  org.apache.lucene.search.Hits;
 import  org.apache.lucene.search.IndexSearcher;
 import  org.apache.lucene.search.PrefixQuery;
 import  org.apache.lucene.search.RangeQuery;

 public   class  PrefixQueryTest  {
    public static void main(String[] args) throws Exception {
        Document doc1 = new Document();
        doc1.add(Field.Text("name", "David"));
        doc1.add(Field.Keyword("title", "doc1"));

        Document doc2 = new Document();
        doc2.add(Field.Text("name", "Darwen"));
        doc2.add(Field.Keyword("title", "doc2"));

        Document doc3 = new Document();
        doc3.add(Field.Text("name", "Smith"));
        doc3.add(Field.Keyword("title", "doc3"));

        Document doc4 = new Document();
        doc4.add(Field.Text("name", "Smart"));
        doc4.add(Field.Keyword("title", "doc4"));

        IndexWriter writer = new IndexWriter("c:/java/index",
                new StandardAnalyzer(), true);
        writer.setUseCompoundFile(true);
        writer.addDocument(doc1);
        writer.addDocument(doc2);
        writer.addDocument(doc3);
        writer.addDocument(doc4);
        writer.close();

        IndexSearcher searcher = new IndexSearcher("c:/java/index");
        Term pre1 = new Term("name", "Da");
        Term pre2 = new Term("name", "da");
        Term pre3 = new Term("name", "sm");

        Hits hits = null;
        PrefixQuery query = null;

        query = new PrefixQuery(pre1);
        hits = searcher.search(query);
        printResult(hits, "前缀为'Da'的文档");
        
        query = new PrefixQuery(pre2);
        hits = searcher.search(query);
        printResult(hits, "前缀为'da'的文档");
        
        query = new PrefixQuery(pre3);
        hits = searcher.search(query);
        printResult(hits, "前缀为'sm'的文档");

    }

    public static void printResult(Hits hits, String key) throws Exception {
        System.out.println("查找 "" + key + "" :");
        if (hits != null) {
            if (hits.length() == 0) {
                System.out.println("没有找到任何结果");
                System.out.println();
            } else {
                System.out.print("找到");
                for (int i = 0; i < hits.length(); i++) {
                    Document d = hits.doc(i);
                    String dname = d.get("title");
                    System.out.print(dname + "   ");
                }
                System.out.println();
                System.out.println();
            }
        }
    }
}

C:/>java  PrefixQueryTest
查找 "前缀为'Da'的文档" :
没有找到任何结果

查找 "前缀为'da'的文档" :
找到doc1 doc2

查找 "前缀为'sm'的文档" :
找到doc3 doc4

注：Lucene的标准分析器在进行分词过滤时将所有的关键字一律转成了小写，所以有上述结果。

(5):多关键字搜索

 

package  ch11;

 import  org.apache.lucene.analysis.standard.StandardAnalyzer;
 import  org.apache.lucene.document.Document;
 import  org.apache.lucene.document.Field;
 import  org.apache.lucene.index.IndexWriter;
 import  org.apache.lucene.index.Term;
 import  org.apache.lucene.search.Hits;
 import  org.apache.lucene.search.IndexSearcher;
 import  org.apache.lucene.search.PhraseQuery;
 import  org.apache.lucene.search.PrefixQuery;

 public   class  PhraseQueryTest  {
    public static void main(String[] args) throws Exception {
        Document doc1 = new Document();
        doc1.add(Field.Text("content", "david mary smith robert"));
        doc1.add(Field.Keyword("title", "doc1"));

        IndexWriter writer = new IndexWriter("c:/java/index",
                new StandardAnalyzer(), true);
        writer.setUseCompoundFile(true);
        writer.addDocument(doc1);
        writer.close();

        IndexSearcher searcher = new IndexSearcher("c:/java/index");
        Term word1 = new Term("content", "david");
        Term word2 = new Term("content","mary");
        Term word3 = new Term("content","smith");
        Term word4 = new Term("content","robert");
        
        Hits hits = null;
        PhraseQuery query = null;

        // 第一种情况，两个词本身紧密相连，先设置坡度为0，再设置坡度为2
        query = new PhraseQuery();
        query.add(word1);
        query.add(word2);
        query.setSlop(0);
        hits = searcher.search(query);
        printResult(hits, "'david'与'mary'紧紧相隔的Document");
        
        query.setSlop(2);
        hits = searcher.search(query);
        printResult(hits, "'david'与'mary'中相隔两个词的短语");
        
        // 第二种情况，两个词本身相隔两个词，先设置坡度为0，再设置坡度为2
        query = new PhraseQuery();
        query.add(word1);
        query.add(word4);
        query.setSlop(0);
        hits = searcher.search(query);
        printResult(hits, "'david'与'robert'紧紧相隔的Document");
        
        query.setSlop(2);
        hits = searcher.search(query);
        printResult(hits, "'david'与'robert'中相隔两个词的短语");
        

    }

    public static void printResult(Hits hits, String key) throws Exception {
        System.out.println("查找 "" + key + "" :");
        if (hits != null) {
            if (hits.length() == 0) {
                System.out.println("没有找到任何结果");
                System.out.println();
            } else {
                System.out.print("找到");
                for (int i = 0; i < hits.length(); i++) {
                    Document d = hits.doc(i);
                    String dname = d.get("title");
                    System.out.print(dname + "   ");
                }
                System.out.println();
                System.out.println();
            }
        }
    }
}

运行结果：
C:/java>java  PrefixQueryTest
查找 "前缀为'Da'的文档" :
没有找到任何结果

查找 "前缀为'da'的文档" :
找到doc1 doc2

查找 "前缀为'sm'的文档" :
找到doc3 doc4

注：对两个紧连的关键字，无论将坡度设置为多少，Lucene总能找到它所在的文档，而对不紧连的关键字，如果坡度值小于它们之间无关词的数量，那么则无法找到。

(6):短语搜索

import  org.apache.lucene.analysis.standard.StandardAnalyzer;
 import  org.apache.lucene.document.Document;
 import  org.apache.lucene.document.Field;
 import  org.apache.lucene.index.IndexWriter;
 import  org.apache.lucene.index.Term;
 import  org.apache.lucene.search.Hits;
 import  org.apache.lucene.search.IndexSearcher;
 import  org.apache.lucene.search.PhrasePrefixQuery;
 import  org.apache.lucene.search.PhraseQuery;
 import  org.apache.lucene.search.RangeQuery;

 public   class  PhrasePrefixQueryTest  {
    public static void main(String[] args) throws Exception {
        Document doc1 = new Document();
        doc1.add(Field.Text("content", "david mary smith robert"));
        doc1.add(Field.Keyword("title", "doc1"));

        IndexWriter writer = new IndexWriter("c:/java/index",
                new StandardAnalyzer(), true);
        writer.addDocument(doc1);
        writer.close();

        IndexSearcher searcher = new IndexSearcher("c:/java/index");
        Term word1 = new Term("content", "david");
        Term word2 = new Term("content", "mary");
        Term word3 = new Term("content", "smith");
        Term word4 = new Term("content", "robert");

        Hits hits = null;
        PhrasePrefixQuery query = null;
        
        query = new PhrasePrefixQuery();
        // 加入可能的所有不确定的词
        query.add(new Term[]{word1, word2});
        // 加入确定的词
        query.add(word4);
        query.setSlop(2);
        hits = searcher.search(query);
        printResult(hits, "存在短语'david robert'或'mary robert'的文档");
        
        
    }

    public static void printResult(Hits hits, String key) throws Exception {
        System.out.println("查找 "" + key + "" :");
        if (hits != null) {
            if (hits.length() == 0) {
                System.out.println("没有找到任何结果");
                System.out.println();
            } else {
                System.out.print("找到");
                for (int i = 0; i < hits.length(); i++) {
                    Document d = hits.doc(i);
                    String dname = d.get("title");
                    System.out.print(dname + "   ");
                }
                System.out.println();
                System.out.println();
            }
        }
    }
}


运行结果：
C:/>java  PhrasePrefixQueryTest
查找 "存在短语'david robert'或'mary robert'的文档" :
找到doc1

(7):相近词搜索

import  org.apache.lucene.analysis.standard.StandardAnalyzer;
 import  org.apache.lucene.document.Document;
 import  org.apache.lucene.document.Field;
 import  org.apache.lucene.index.IndexWriter;
 import  org.apache.lucene.index.Term;
 import  org.apache.lucene.search.FuzzyQuery;
 import  org.apache.lucene.search.Hits;
 import  org.apache.lucene.search.IndexSearcher;

 public   class  FuzzyQueryTest  {
    public static void main(String[] args) throws Exception {
        Document doc1 = new Document();
        doc1.add(Field.Text("content", "david"));
        doc1.add(Field.Keyword("title", "doc1"));

        Document doc2 = new Document();
        doc2.add(Field.Text("content", "sdavid"));
        doc2.add(Field.Keyword("title", "doc2"));

        Document doc3 = new Document();
        doc3.add(Field.Text("content", "davie"));
        doc3.add(Field.Keyword("title", "doc3"));

        IndexWriter writer = new IndexWriter("c:/java/index",
                new StandardAnalyzer(), true);
        writer.addDocument(doc1);
        writer.addDocument(doc2);
        writer.addDocument(doc3);
        writer.close();

        IndexSearcher searcher = new IndexSearcher("c:/java/index");
        Term word1 = new Term("content", "david");

        Hits hits = null;
        FuzzyQuery query = null;

        query = new FuzzyQuery(word1);
        hits = searcher.search(query);
        printResult(hits,"与'david'相似的词");
    }

    public static void printResult(Hits hits, String key) throws Exception {
        System.out.println("查找 "" + key + "" :");
        if (hits != null) {
            if (hits.length() == 0) {
                System.out.println("没有找到任何结果");
                System.out.println();
            } else {
                System.out.print("找到");
                for (int i = 0; i < hits.length(); i++) {
                    Document d = hits.doc(i);
                    String dname = d.get("title");
                    System.out.print(dname + "   ");
                }
                System.out.println();
                System.out.println();
            }
        }
    }
}

(8):通配符搜索

import  org.apache.lucene.analysis.standard.StandardAnalyzer;
 import  org.apache.lucene.document.Document;
 import  org.apache.lucene.document.Field;
 import  org.apache.lucene.index.IndexWriter;
 import  org.apache.lucene.index.Term;
 import  org.apache.lucene.search.Hits;
 import  org.apache.lucene.search.IndexSearcher;
 import  org.apache.lucene.search.WildcardQuery;

 public   class  WildcardQueryTest  {
    public static void main(String[] args) throws Exception {
        Document doc1 = new Document();
        doc1.add(Field.Text("content", "whatever"));
        doc1.add(Field.Keyword("title", "doc1"));
        
        Document doc2 = new Document();
        doc2.add(Field.Text("content", "whoever"));
        doc2.add(Field.Keyword("title", "doc2"));
        
        Document doc3 = new Document();
        doc3.add(Field.Text("content", "however"));
        doc3.add(Field.Keyword("title", "doc3"));
        
        Document doc4 = new Document();
        doc4.add(Field.Text("content", "everest"));
        doc4.add(Field.Keyword("title", "doc4"));
        
        IndexWriter writer = new IndexWriter("c:/java/index",
                new StandardAnalyzer(), true);
        writer.addDocument(doc1);
        writer.addDocument(doc2);
        writer.addDocument(doc3);
        writer.addDocument(doc4);
        writer.close();

        IndexSearcher searcher = new IndexSearcher("c:/java/index");
        Term word1 = new Term("content", "*ever");
        Term word2 = new Term("content", "wh?ever");
        Term word3 = new Term("content", "h??ever");
        Term word4 = new Term("content", "ever*");
        WildcardQuery query = null;
        Hits hits = null;
        
        query = new WildcardQuery(word1);
        hits = searcher.search(query);
        printResult(hits, "*ever");
        
        query = new WildcardQuery(word2);
        hits = searcher.search(query);
        printResult(hits, "wh?ever");
        
        query = new WildcardQuery(word3);
        hits = searcher.search(query);
        printResult(hits, "h??ever");
        
        query = new WildcardQuery(word4);
        hits = searcher.search(query);
        printResult(hits, "ever*");
    }
    
    public static void printResult(Hits hits, String key) throws Exception {
        System.out.println("查找 "" + key + "" :");
        if (hits != null) {
            if (hits.length() == 0) {
                System.out.println("没有找到任何结果");
                System.out.println();
            } else {
                System.out.print("找到");
                for (int i = 0; i < hits.length(); i++) {
                    Document d = hits.doc(i);
                    String dname = d.get("title");
                    System.out.print(dname + "   ");
                }
                System.out.println();
                System.out.println();
            }
        }
    }
}

运行结果：
C:/>java   WildcardQueryTest
查找 "*ever" :
找到doc1   doc2   doc3

查找 "wh?ever" :
找到doc2

查找 "h??ever" :
找到doc3

查找 "ever*" :
找到doc4

nobody_java
关注
Lucene中各种Query的用法与场景分析
AI大模型应用之禅
06-01 941
Lucene中各种Query的用法与场景分析 1.背景介绍 在现代信息时代,数据已经成为了企业和个人的重要资产。随着数据量的不断增长,有效地检索和利用这些数据变得至关重要。Apache Lucene是一个高性能、全功能的搜索引擎库,它提供了强大的索引和搜索功能,可以帮助我们快速地
Lucene原理与代码实例讲解
AI天才研究院
06-13 1079
Lucene原理与代码实例讲解 1.背景介绍 在当今信息时代,数据量呈现爆炸式增长,如何高效地检索和管理海量数据成为了一个巨大挑战。Apache Lucene作为一个高性能、全功能的搜索引擎库,凭借其优秀的索引和查询能力,成为了广受欢迎的解决方案之一。无论是构建网站搜索、电子商务平台、文档管理
lucene整理4 -- 各种Query
xiarilian12的博客
12-29 488
1. 各种Query 1.1. 概述 query.toString()查看原子查询 1.2. 使用特定的分析器搜索 [code="java"]IndexSearcher searcher = new IndexSearcher(path ); Hits hits = null; Query query = null; QueryParser parser =ne...
lucene搜索方式（query类型）
weixin_30518397的博客
08-15 214
Lucene有多种搜索方式，可以根据需要选择不同的方式。 1、词条搜索（单个关键字查找） 主要对象是TermQuery 调用方式如下： Term term=new Term(字段名,搜索关键字);Query query=new TermQuery(term);Hits hits=searcher.search(query); 2、组合搜索（允许多个关键字组合搜索）...
Lucene中不同搜索类型的使用方法、基本概念、应用场景、差异对比，并通过表格进行总结
最新发布
爱的叹息的专栏
04-29 891
Lucene中不同搜索类型的使用方法、基本概念、应用场景、差异对比，并通过表格进行总结
lucene当中的各种query（一）
wwty
06-03 338
TermQuery 首先介绍最基本的查询，如果你想执行一个这样的查询：“在content域中包含‘lucene’的document”，那么你可以用TermQuery： Term t = new Term("content", " lucene"); Query query = new TermQuery(t);   BooleanQuery 如果你想这么查询：“在content域中包含...
理解Lucene中的Query
03-12 478
Query是一个接口，它有很多实现类。 QueryParser是Query解析器，用于将一个字符串解析为一个Query对象，这个Query对象可能属于TermQuery，也可能属于PhraseQuery、TermQuery、BooleanQuery等。可以通过Query对象的getClass()方法来查看这个对象到底是哪个实现类。 Lucene已经给我们提供了很多Query查询器，如Ph...
Lucene中的 Query对象
weixin_34064653的博客
12-08 111
"Lucene中的 Query对象"： 检 索前，需要对检索字符串进行分析，这是由queryparser来完成的。为了保证查询的正确性，最好用创建索引文件时同样的分析器。 queryparser解析字符串时，可以指定查询域，实际可以在字符串中指定一个或多个域。例如：“info:电视台 and id:3329”，“info:电视台”，“电视台”，假如不指定默认域，就会在默认域查询。   ...
最新全文检索 lucene-5.2.1 入门经典实例
04-12
《最新全文检索 Lucene-5.2.1 入门经典实例》 Lucene是一个开源的全文检索库，由Apache软件基金会开发并维护。作为Java编写的一个强大的信息检索引擎，它为开发者提供了构建高效、可扩展的搜索功能的工具。在5.2.1...
lucene 4.8 实例
08-07
本文将深入探讨 Lucene 4.8 版本中的关键特性和实例应用。 一、Lucene 的核心概念 1. 文档（Document）：在 Lucene 中，文档是信息的基本单位，它可以包含多个字段（Field），如标题、正文、作者等。 2. 字段...
构建各种Lucene Query
小嘴冰凉
08-24 269
[code="java"] [size=x-large] 搜索流程中的第二步就是构建一个Query。下面就来介绍Query及其构建。 当用户输入一个关键字，搜索引擎接收到后，并不是立刻就将它放入后台开始进行关键字的检索，而应当首先对这个关键字进行一定的分析和处理，使之成为一种后台可以理解的形式，只有这样，才能提高检索的效率，同时检索出更加有效的结果。那么，在Lucene中，这种处理，...
lucene常见查询
02-17 5607
package com.lucene.query; import java.io.File; import java.io.IOException; import java.io.StringReader; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.TokenStre
lucene Query搜索
qq_29606255的博客
08-14 292
lucene Query 搜索 WildcardQuery通配符查询，给整个文本建立索引，通过通配符匹配搜索，通过通配符的全文搜索
java lucene 例子_lucene实例使用
weixin_35976717的博客
02-13 364
说明一下,这一篇文章的用到的lucene,是用2.0版本的,主要在查询的时候2.0版本的lucene与以前的版本有了一些区别.其实这一些代码都是早几个月写的,自己很懒,所以到今天才写到自己的博客上,高深的文章自己写不了，只能记录下一些简单的记录与点滴，其中的代码算是自娱自乐的，希望高手不要把重构之类的砸下来...1、在windows系统下的的C盘，建一个名叫s的文件夹,在该文件夹里面随便建三个tx...
lucene当中的各种query（三）
xiaomin1991222的专栏
08-20 359
MultiTermQuery包含以下query： FuzzyQuery, NumericRangeQuery, PrefixQuery, TermRangeQuery, WildcardQuery FuzzyQuery是一种模糊查询，它可以简单地识别两个相近的词语。 即相似度匹配 NumericRangeQuery数字形式的范围查询 PrefixQuery前缀搜索A Query tha...
Lucene 学习 Query
ivolianer的专栏
09-16 522
7
Lucene的各种query
被欺诈的青春
06-05 1414
Lucene的各种query Lucene支持基于词条的TermQuery、RangeQuery、PrefixQuery、BolleanQuery、PhraseQuery、WildcardQuery、FuzzyQuery，另外lucene提供了功能强大的QueryParse用于从查询表达式中分析出查询请求。   1．TermQuery与QueryParser 单
Lucene知识总结(Query篇)
hts0o0的专栏
06-19 1084
继承Query类的一系列子类操作 1.TermQuery 用于词条搜索(单个关键字) 调用如下： Term term = new Term("key","value"); Query query = new TermQuery(term); 2.BooleanQuery 组合搜索(允许多个关键字组合查询) 调用如下: Term term1=new Term("key","valu
lucene全文检索
小孩与狗的博客
02-24 212
全文检索 什么是全文检索 数据分类 结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。 非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等磁盘上的文件 结构化数据搜索 常见的结构化数据也就是数据库中的数据。在数据库中搜索很容易实现，通常都是使用sql语句进行查询，而且能很快的得到查询结果。 为什么数据库搜索很容易？ 因为数据库中的数据存储是有规律的，有行有列而且数据格式、数据长度都是固定的。 非结构化数据查询方法 （1）顺序扫描法(Serial Scanning) ​ 所谓顺序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值