【转载】lucene整理 -- 概念 搜索 排序
?
lucene整理1 -- 概念
分类：?lucene2010-03-2322:34?52人阅读?评论(0)?收藏?举报
1.????概述
Lucene是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎。Lucene以其方便使用、快速实施以及灵活性受到广泛的关注。它可以方便地嵌入到各种应用中实现针对应用的全文索引、检索功能，本总结使用lucene--2.3.2。
2.????lucene?的包结构
1、org.apache.lucene.analysis对需要建立索引的文本进行分词、过滤等操作,?语言分析器，主要用于的切词Analyzer是一个抽象类，管理对文本内容的切分词规则。
2、org.apache.lucene.analysis.standard是标准分析器
3、org.apache.lucene.document提供对Document和Field的各种操作的支持。索引存储时的文档结构管理，类似于关系型数据库的表结构。Document相对于关系型数据库的记录对象，Field主要负责字段的管理。
4、org.apache.lucene.index是最重要的包，用于向Lucene提供建立索引时各种操作的支持。索引管理，包括索引建立、删除等。索引包是整个系统核心，全文检索的根本就是为每个切出来的词建索引，查询时就只需要遍历索引，而不需要去正文中遍历，从而极大的提高检索效率。
5、org.apache.lucene.queryParser提供检索时的分析支持。查询分析器，实现查询关键词间的运算，如与、或、非等。
6、org.apache.lucene.search?负责检索。检索管理，根据查询条件，检索得到结果。
7、org.apache.lucene.store提供对索引存储的支持。数据存储管理，主要包括一些底层的I/0操作。
8、org.apache.lucene.util提供一些常用工具类和常量类的支持
3.????索引文件格式
a)?????????.fnm格式??包含了Document中所有field名称
b)????????.fdt与.fdx格式??.fdt文件用于存储具有Store.YES属性的Field的数据；.fdx是一个索引，用于存储Document在.fdt中的位置。
c)????????.tis?与.tii格式??.tis文件用于存储分词后的词条（Term），而.tii就是它的索引文件，它表明了每个.tis文件中的词条的位置。
d)????????deletable格式?文档被删除后，会首先在deletable文件中留下一个记录，要真正删除时，才将索引除去。
e)?????????复合索引格式?.cfs
使用IndexWriter的useCompoundFile()??默认为True
方法
描述
void add(Field field)
往Document对象中添加字段
void removeField(String name)
删除字段。若多个字段以同一个字段名存在，则删除首先添加的字段；若不存在，则Document保持不变
void removeFields(String name)
删除所有字段。若字段不存在，则Document保持不变
Field getField（String name）
若多个字段以同一个字段名存在，则返回首先添加的字段；若字段不存在，则Document保持不变
Enumeration fields()
返回Document对象的所有字段，以枚举类型返回
Field [] getFields(String name)
根据名称得到一个Field的数组
String [] getValues(String name)
根据名称得到一个Field的值的数组
?
Document doc1 =?new?Document();
doc1.add(new?Field("name",?"word1word2 word3",
Field.Store.NO,Field.Index.TOKENIZED));
Document doc2 =?new?Document();
doc2.add(new?Field("name",?"word1word2 word3",
Field.Store.NO,Field.Index.TOKENIZED));
1)????????public Field(Stringname,String value,Store store,Index index);//直接的字符串方式
2)????????public Field(Stringname,String value,Store store,Index index,TermVector termVector);
3)????????public Field(Stringname,String value,Reader reader);//使用Reader从外部传入
4)????????public Field(Stringname,String value,Reader reader,TermVector termVector);
5)????????public Field(Stringname,byte[] value,Store store)//使用直接的二进制byte传入
当Field值为二进制时，可以使用Lucene的压缩功能将其值进行压缩。
静态属性
描述
Store.NO
表示该Field不需要存储
Store.YES
表示该Field需要存储
Store.COMPRESS
表示用压缩方式来保存这个Field的值
静态属性
描述
Index.NO
不需要索引
Index.TOKENIZED
先被分词再被索引
Index.UN_TOKENIZED
不对该Field进行分词，但会对它进行索引
Index.NO_NORMS
对该Field进行索引，但是不使用Analyzer，同时禁止它参加评分，主要是为了减少内存的消耗。
?
new Field("name", "word1 word2word3",Field.Store.YES,Field.Index.TOKENIZED)
?
1)????????publicIndexWriter(String path,Analyzer a,Boolean create)
2)????????publicIndexWriter(File path,Analyzer a,Boolean create)
3)????????publicIndexWriter(Directory d,Analyzer a,Boolean create)
第一个参数：索引存放在什么地方
第二个参数：分析器，继承自org.apache.lucene.analysis.Analyzer类
第三个参数：为true时，IndexWriter不管目录内是否已经有索引了，一律清空，重新建立；当为false时，则IndexWriter会在原有基础上增量添加索引。所以在更新的过程中，需要设置该值为false。
public void addDocument(Document doc)
public void addDocument(Document doc,Analyzer analyzer)//使用一个开发者自定义的，而非事先在构建IndexWriter时声明的Analyzer来进行分析
writer.addDocument(doc1);
1)????????mergeFactor控制Lucene在把索引从内存写入磁盘上的文件系统时内存中最大的Document数量，同时它还控制内存中最大的Segment数量。默认为10.
writer.setMergeFactor(10);
2)????????maxMergeDocs限制一个Segment中最大的文档数量。一个较大的maxMergeDocs适用于对大批量的文档建立索引，增量式的索引则应使用较小的maxMergeDocs。
writer.setMaxMergeDocs(1000);
3)????????minMergeDocs用于控制内存中持有的文档数量的，它对磁盘上的Segment大小没有任何影响。
maxFieldLength限制Field的长度，默认值为10000.最大值100000个。
public void setMaxFieldLength(int maxFieldLength)
writer.addDocument(doc1);
writer.setMaxFieldLength(100000);
writer.addDocument(doc2);
setUseCompoundFile(Boolean)?默认true
writer.setUseCompoundFile(true);//复合索引
writer.setUseCompoundFile(false);
writer.optimize();
将磁盘上的多个segment进行合并，组成一个全新的segment。这种方法并不会增加建索时的速度，反而会降低建索的速度。所以应该在建完索引后在调用这个函数
IndexWriter writer = new IndexWriter(path, newStandardAnalyzer(), true);
writer.addDocument(doc1);
writer.addDocument(doc2);
Sytem.out.println(writer.docCount());
writer.close();
IndexSearcher searcher = new IndexSearcher(path);
Hits?hits =?null;
Query query =?null;
QueryParser parser =new QueryParser("name", newStandardAnalyzer());
query =parser.parse("word1");
hits = searcher.search(query);
System.out.println("查找?word1?共" +hits.length() + "个结果");
?
Directory：用于索引的存放位置
a)?????????FSDirectory.getDirectory(path,true)第二个参数表示删除掉目录内原有内容
IndexWriter writer = newIndexWriter(FSDirectory.getDirectory(path, true), new StandardAnalyzer(),true);//删除原有索引
或
FSDirectory fsDir=FSDirectory.getDirectory(path,true);
IndexWriter writer = new IndexWriter(fsDir, newStandardAnalyzer(), true);
b)????????RAMDirectory在内存中存放，读取速度快，但程序一运行结束，它的内容就不存在了
RAMDirectory ramDir=new RAMDirectory();
IndexWriter writer = new IndexWriter(ramDir, newStandardAnalyzer(), true);
?
或
IndexWriter writer = new IndexWriter(new RAMDirectory(), newStandardAnalyzer(), true);
IndexReader类――索引的读取工具
IndexReader reader=IndexReader.open(path);
reader.deleteDocument(0);//删除第一个
reader.close();
reader.undeleteAll();
reader.deleteDocuments(newTerm("name","word1"));
若要真正物理删除，则只需使用IndexWriter对索引optimize一次即可！
IndexReader reader=IndexReader.open(path);
???????????for(int?i=0;i<reader.numDocs();i++){
??????????????System.out.println(reader.document(i));
???????????}
???????????System.out.println("版本："+reader.getVersion());
???????????System.out.println("索引内的文档数量："+reader.numDocs());
???????????//reader.deleteDocuments(newTerm("name","word1"));
???????????Term term1=new?Term("name","word1");
???????????TermDocs docs=reader.termDocs(term1);
???????????while(docs.next())
???????????{
??????????????System.out.println("含有所查找的"+term1+"的Document的编号为"+docs.doc());
??????????????System.out.println("Term在文档中的出现次数"+docs.freq());
???????????}
???????????reader.close();
?
集成了IndexWriter的大部分功能和IndexReader中对索引删除的功能?------ Lucene2.0的新类
?
public?static?void?main(String[]args)?throws?Exception {
???????IndexModifier modifier=new?IndexModifier("C://Q1",new?StandardAnalyzer(),true);
???????Document doc1=new?Document();
???????doc1.add(new?Field("bookname","钢铁是怎样炼成的",Field.Store.YES,Field.Index.TOKENIZED));
???????Document doc2=new?Document();
???????doc2.add(new?Field("bookname","山山水水",Field.Store.YES,Field.Index.TOKENIZED));
???????modifier.addDocument(doc1);
???????modifier.addDocument(doc2);
??????
???????System.out.println(modifier.docCount());
???????modifier.setUseCompoundFile(false);
???????modifier.close();
??????
???????IndexModifier mo=new?IndexModifier("C://Q1",new?StandardAnalyzer(),false);
???????mo.deleteDocument(0);
???????System.out.println(mo.docCount());
???????mo.close();
????}
?
IndexSearcher searcher = new IndexSearcher(String path);
IndexSearcher searcher = new IndexSearcher(Directory directory);
IndexSearcher searcher = new IndexSearcher(IndexReader r);
IndexSearcher searcher = new IndexSearcher(IndexReader r,BooleancloseReader);
IndexSearcher searcher = new IndexSearcher(path);
IndexSearcher searcher = newIndexSearcher(FSDirectory.getDirectory(path,false) );
//返回Hits对象
public Hits search(Query query)
public Hits search(Query query,Filter filter)
public Hits search(Query query,Sort sort)
public Hits search(Query query,Filter filter,Sort sort)
?
//检索只返回得分最高的Document
public TopDocs search(Query query,Filter filter,int n)
public TopDocs search(Weight weight,Filter filter,int n)
public TopFieldDocs search(Weight weight,Filter filter,intn,Sort sort)
public TopFieldDocs search(Query query,Filter filter,int n,Sortsort)
?
//传入HitCollector,将结果保存在HitCollector中
public void search(Query query,HitCollector results)
public void search(Query query,Filter filter,HitCollectorresults)
public void search(Weight weight,Filter filter,HitCollectorresults)
public Explaination explain(Query query,int doc)throwsIOException
for(int?i=0;i<hits.length()&&i<10;i++)
{
????Document d=hits.doc(i);
????System.out.println(i+""+hits.score(i)+" "+d.get("contents"));
System.out.println(searcher.explain(query,hits.id(i)).toString());
}
IndexSearcher searcher =?new?IndexSearcher(path);
Hits hits =?null;
Query query =?null;
?
QueryParser parser =new?QueryParser("contents",?new?StandardAnalyzer());
?
query =parser.parse("11");
hits = searcher.search(query);
System.out.println("查找?word1?共"?+ hits.length()+?"个结果");
?
for(int?i=0;i<hits.length()&&i<10;i++)
{
????Document d=hits.doc(i);
????System.out.println(d+""+i+" "+hits.score(i)+""+d.get("contents"));
}
searcher.close();
Hits类――检索结果
?
?
方法名
描述
int length()
返回搜索到结果的总数量
Document doc(int i)
返回第i个文档
int id(int i)
返回第i个文档的内部ID号
float score(int i)
返回第i个文档的得分
Iterator iterator()
取得Hits集合的遍历对象
for(int?i=0;i<hits.length()&&i<10;i++)
{
????Document d=hits.doc(i);
????System.out.println(d+""+" "+hits.score(i)+" "+d.get("contents"));
System.out.println("文档的内部ID号:" +hits.id(i));
}
??????????默认为“或”关系
Query query = null;
QueryParser parser =newQueryParser("contents", new StandardAnalyzer());
query =parser.parse("helloworld!");
System.out.println(query.toString());
??????????改变默认布尔逻辑
Query query = null;
QueryParser parser =newQueryParser("contents", new StandardAnalyzer());
parser.setDefaultOperator(QueryParser.AND_OPERATOR);
query =parser.parse("helloworld");//若world后加！会出错
System.out.println(query.toString());
??????????AND OR NOT –?关键字
也可以不用改变默认布尔逻辑，而直接让用户在输入关键字时指定不同词条间的布尔联系。例如，用户输入?hello AND world??必须为大写
逻辑与：AND?（大写）
逻辑或：OR??（大写）
逻辑非：-???例如：?hello - world
也可以是NOT??例如：?hello NOT world
不进行分词，将其完整的作为一个词条进行处理，则需要在词组的外面加上引号
String queryStr="/"God helpsthose who help themselves/"";
QueryParser parser = newQueryParser("bookname",new StandardAnalyzer());
parser.setDefaultOperator(QueryParser.AND_OPERATOR);
Query query=parser.parse(queryStr);
System.out.println(query.toString());
String queryStr="/"God helpsthose who help themselves/"~1";//设置坡度为1
QueryParser parser = newQueryParser("bookname",new StandardAnalyzer());
Query query=parser.parse(queryStr);
System.out.println(query.toString());
String queryStr="wor?"
QueryParser parser = newQueryParser("bookname",new StandardAnalyzer());
parser.setDefaultOperator(QueryParser.AND_OPERATOR);
Query query=parser.parse(queryStr);
System.out.println(query.toString());
String queryStr="linuxpublishdate:2006-09-01";
QueryParser parser = newQueryParser("bookname",new StandardAnalyzer());
parser.setDefaultOperator(QueryParser.AND_OPERATOR);
Query query=parser.parse(queryStr);
System.out.println(query.toString());
例如：要求用户选择某一方面的
String queryStr="[1990-01-01 TO1998-12-31]";
QueryParser parser=newQueryParser("publishdate",
new StandardAnalyzer());
Query query=parser.parse(queryStr);
System.out.println(query.toString());
?
输出结果为publishdate:[081xmghs0TO 0boeetj3z]
因为建立索引时，如果按照日期表示的字符串来进行索引，实际上比较的是字符串的字典顺序。而首先将日期转为以毫秒计算的时间后，则可以精确地比较两个日期的大小了。于是，lucene提供DateTools工具，用来完成其内部对时间的转化和处理，将毫秒级的时间转化为一个长字符串来进行表示，并进行索引。所以，遇到日期型数据时，最好用DateTools进行转换，再进行索引！
//在不同的Field上进行不同的查找
public static Query parse(String []queries,String[]fields,Analyzer analyzer)throws ParseException
?
//在不同的Field上进行同一个查找，指定它们之间的布尔关系
public static Query parse(String query,String[]fields,BooleanClause.Occur[] flags,Analyzer analyzer) throws ParseException
?
//在不同的Field上进行不同的查找，指定它们之间的布尔关系
public static Query parse(String []queries,String []fields,BooleanClause.Occur[] flags,Analyzer analyzer)throws ParseException
String [] queries={"钢","[10 TO 20]"};
String[] fields={“bookname”,”price”};
BooleanClause.Occur[]clauses={BooleanClause.Occur.MUST,BooleanClause.Occur.MUST};
Queryquery=MultiFieldQueryParser.parse(queries,fields,clauses,newStandardAnalyzer());
System.out.println(query.toString());
?
IndexSearcher searcher1=newIndexSearcher(path1);
IndexSearcher searcher2=new IndexSearcher(path2);
IndexSeacher []searchers={searcher1,seacher2};
MultiSearcher searcher=newMultiSearcher(searchers);
Hits hits=searcher.search(query);
for(int i=0;i<hits.length();i++){
????System.out.println(hits.doc(i));
}
IndexSearcher searcher1=newIndexSearcher(path1);
IndexSearcher searcher2=newIndexSearcher(path2);
IndexSearcher []searchers={searcher1,searcher2};
ParallelMultiSearcher searcher=newParallelMultiSearcher(searchers);
long start=System.currentTimeMillis();
Hits hits=searcher.search(query);
long end=System.currentTimeMillis();
System.out.println((end-start)+"ms");
?
public Sort()
public Sort(String field)
public Sort(String field,Booleanreverse)??//默认为false，降序排序
public Sort(String[] fields)
public Sort(SortField field)
public Sort(SortField[] fields)
Sort sort=new Sort(“bookname”);按照“bookname“这个Field值进行降序排序
Sort sort=new Sort(“bookname”,true) //升序排序
Sort sort=new Sort(new String[]{“bookNumber”,”bookname”,”publishdate”});按照三个Field进行排序，但无法指定升序排序，所以用SortField
public SortField(String field)
public SortField(String field,Booleanreverse)
public SortField(String field,int type)//type表示当前Field值的类型
public SortField(String field,inttype,boolean reverse)??//默认为false，升序
Field值的类型：SortField.STRING、SortField.INT、SortField.FLOAT
SortField sf1=newSortField(“bookNumber”,SortField.INT,false);
SortField sf2=newSortField(“bookname”,SortField.STRING,false);
Hitshits=searcher.search(query,Sort.RELEVANCE);
Hits hits=searcher.search(query,Sort.INDEXORDER);
Sort sort=new Sort();
SortField sf=newSortField(“bookNumber”,SortField.INT,false);
sort.setSort(sf);
Hits hits=searcher.search(query,sort);
Sort sort=new Sort();
SortField sf1=new SortField(“bookNumber”,SortField.INT,false);//升序
SortField sf2=new SortField(“publishdate”,SortField.STRING,true);//降序
sort.setSort(new SortField[]{sf1,sf2});
Hits hits=searcher.search(query,sort);
String str1=”我”; String str2=”你”;
Collatorco1=Collator.getInstance(Locale.CHINA);
Collatorco2=Collator.getInstance(Locale.JAPAN);
System.out.println(Locale.CHINA+”:”+co1.compare(str1，str2));
System.out.println(Locale.JAPAN+”:”+co2.compare(str1,str2));
输出结果为：
zh_CN:1
ja_JP:-1
所以
public SortField(String field,Localelocale)
public SortField(String field,Localelocale,boolean reverse)
使用public Hitssearch(Query query,Filter filter)
（1）简单过滤
Hits hits=searcher.search(query,newAdvancedSecurityFilter());//过滤掉securitylevel为0的结果
（2）范围过滤—RangeFilter
只显示中间的
RangeFilter filter=newRangeFilter(“publishdate”,”1970-01-01”,”1998-12-31”,true,true”);
Hits hits=searcher.search(query,filter);
?
无上边界
public static RangeFilter More(Stringfieldname,String lowerTerm)
?
无下边界
public static RangeFilter Less(Stringfieldname,String upperTerm)
(3)在结果中查询QueryFilter
RangeQuery q=new RangeQuery(newTerm(“publicshdate”,”1970-01-01”),
newTerm(“publishdate”,”1999-01-01”),true);
QueryFilter filter=new QueryFilter(q);
Hits hits=searcher.search(query,filter);
??????????标准过滤器：StandardAnalyzer
??????????大小写转换器：LowerCaseFilter
??????????忽略词过滤器：StopFilter
public StopFilter(TokenStreaminput,String [] stopWords)
public StopFilter(TokenStream in,String[] stopWords,boolean ignoreCase)
public StopFilter(TokenStream input,SetstopWords,boolean ignoreCase)
public StopFilter(TokenStream in, SetstopWords)
其中，参数TokenStream代表当前正在进行处理的流；String类型的数组代表一个用数组表示的忽略词集合；Set类型的参数与String一样，是用来表示忽略词集合的；boolean表示当与忽略词集合中的词进行匹配时，是否需要忽略大小写。
??????????长度过滤器：LengthFilter
??????????PerFieldAnalyzerWrapper
??????????WhitespaceAnalyzer
String str="str1 str2 str3";
???????StringReader reader=newStringReader(str);
???????Analyzer anlyzer=newWhitespaceAnalyzer();
??????
???????TokenStreamts=anlyzer.tokenStream("", reader);
???????Token t=null;
???????while( (t=ts.next())!=null ){
???????????System.out.println(t.termText());
???????}
??????????单字分词
??????????二分法：CJKAnalyzer、中科院ICTCLAS分词、JE分词
??????????词典分词
import jeasy.analysis.MMAnalyzer;
IndexWriter writer = newIndexWriter(INDEX_STORE_PATH, new MMAnalyzer()
, true);
String str=" Lucene是一个全文检索引擎的架构，"+
???????????"提供了完整的查询引擎和索引引擎。Lucene以其方便使用、快" +
???????????"速实施以及灵活性受到广泛的关注。它可以方便地嵌入到各种应用"+
???????????"中实现针对应用的全文索引、检索功能，本总结使用lucene--2.3.2。";
???????MMAnalyzer analyzer=new MMAnalyzer();
???????try{
???????????System.out.println(analyzer.segment(str,"|"));
???????}
???????catch(Exception e)
???????{
???????????e.printStackTrace();
???????}
输出结果：lucene|一个|全文|检索|引擎|架构|提供|完整|查询|。。。。
MMAnalyzer analyzer=new MMAnalyzer(4);
MMAnalyzer.addWord(String word);
MMAnalyzer.addDictionary(Reader reader);
?
MMAnalyzer analyzer=new MMAnalyzer();
MMAnalyzer.addWord("迈克尔雷第");
?
RAMDirectory RAMDir=new RAMDirectory();
IndexWriter writer = newIndexWriter(RAMDir, new StandardAnalyzer(), true);//删除原有索引
IndexWriter writer2=newIndexWriter(FSDirectory.getDirectory(path,true),
new StandardAnalyzer(), true);
writer.addDocument(doc1);
writer2.addDocument(doc2);
writer.close();
writer2.addIndexes(newDirectory[]{RAMDir});
writer2.close();
注意：在合并前一定要先关闭要加的索引器。
query.toString()查看原子查询
IndexSearcher searcher = newIndexSearcher(path );
Hits hits = null;
Query query = null;
QueryParser parser =newQueryParser("contents", new StandardAnalyzer());
query =parser.parse("11 a andhello");
hits=searcher.search(query); //查找?name:11name:hello?共1个结果
System.out.println("查找?"+query.toString()+"?共"+ hits.length() + "个结果");
Query query = null;
query=new TermQuery(newTerm("name","word1 a and"));
hits=searcher.search(query);//?查找?name:word1 a and?共0个结果
System.out.println("查找?"+query.toString()+"?共"+ hits.length() + "个结果");
1.和：?MUST与MUST_NOT
2.或：?SHOULD与SHOULD
3.A与B的并集－B??MUST与MUST_NOT
Query query1=null;
Query query2=null;
BooleanQuery query=null;
query1=new TermQuery(newTerm("name","word1"));
query2=new TermQuery(newTerm("name","word2"));
query=new BooleanQuery();
query.add(query1,BooleanClause.Occur.MUST);
query.add(query2,BooleanClause.Occur.MUST_NOT);
Term beginTime=newTerm("time","200001");
Term endTime=newTerm("time","200005");
RangeQuery query=null;
query=newRangeQuery(beginTime,endTime,false);//不包含边界值
Term pre1=newTerm("name","wor");
PrefixQuery query=null;
query = new PrefixQuery(pre1);
a)默认坡度为0
PhraseQuery query = new PhraseQuery();
query.add(new Term(“bookname”,”钢”));
query.add(new Term(“bookname”,”铁”));
Hits hits=searcher.search(query); //搜索“钢铁”短语，而非“钢”和“铁”
b)设置坡度，默认为0
PhraseQuery query = new PhraseQuery();
query.add(new Term(“bookname”,”钢”));
query.add(new Term(“bookname”,”铁”));
query.setSlop(1);
Hits hits=searcher.search(query);//搜索“钢铁”或“钢*铁”中含一字
a)
MultiPhraseQuery query=newMultiPhraseQuery();
//首先向其中加入要查找的短语的前缀
query.add(new Term(“bookname”,”钢”));
//构建3个Term，作为短语的后缀
Term t1=new Term(“bookname”,”铁”);
Term t2=new Term(“bookname”,”和”);
Term t3=new Term(“bookname”,”要”);
//再向query中加入所有的后缀，与前缀一起，它们将组成3个短语
query.add(new Term[]{t1,t2,t3});
Hits hits=searcher.search(query);
for(int i=0;i<hits.length();i++)
????System.out.println(hits.doc(i));
b)
MultiPhraseQuery query=newMultiPhraseQuery();
Term t1=new Term(“bookname”,”钢”);
Term t2 = new Term(“bookname”,”和”);
query.add(new Term[]{t1,t2});
query.add(new Term(“bookname”,”铁”));
c)
MultiPhraseQuery query=newMultiPhraseQuery();
Term t1=new Term(“bookname”,”钢”);
Term t2 = new Term(“bookname”,”和”);
query.add(new Term[]{t1,t2});
query.add(new Term(“bookname”,”铁”));
Term t3=new Term(“bookname”,”是”);
Term t4=new Term(“bookname”,”战”);
query.add(new Term[]{t3,t4});
使用的算法为levenshtein算法，在比较两个字符串时，将动作分为3种：
l?????????加一个字母
l?????????删一个字母
l?????????改变一个字母
FuzzyQuery query=new FuzzyQuery(newTerm(“content”,”work”));
?
public FuzzyQuery(Term term)
public FuzzyQuery(Term term,floatminimumSimilarity)throws IllegalArgumentException
public FuzzyQuery(Term term,floatminimumSimilarity,int prefixLength)throws IllegalArgumentException
其中minimumSimilarity为最小相似度，越小则文档的数量越多。默认为0.5.其值必须<1.0
FuzzyQuery query=new FuzzyQuery(newTerm(“content”,”work”),0.1f);
其中prefixLength表示要有多少个前缀字母必须完全匹配
FuzzyQuery query=new FuzzyQuery(newTerm(“content”,”work”),0.1f,1);
*?表示0到多个字符
??表示一个单一的字符
WildcardQuery query=newWildcardQuery(new Term(“content”,”?qq*”));
效果和TermQuery相同
SpanTermQuery query=newSpanTermQuery(new Term(“content”,”abc”));
从Field内容的起始位置开始，在一个固定的宽度内查找所指定的词条
SpanFirstQuery query=newSpanFirstQuery(new Term(“content”,”abc”),3);//是第3个word，不是byte
SpanNearQuery相当与PhaseQuery
SpanTermQuery people=newSpanTermQuery(new Term(“content”,”mary”));
SpanTermQuery how=new SpanTermQuery(newTerm(“content”,”poor”));
SpanNearQuery query=newSpanNearQuery(new SpanQuery[]{people,how},3,false);
把所有SpanQuery的结果合起来
SpanTermQuery s1=new SpanTermQuery(newTerm(“content”,”aa”);
SpanTermQuery s2=new SpanTermQuery(newTerm(“content”,”cc”);
SpanTermQuery s3=new SpanTermQuery(newTerm(“content”,”gg”);
SpanTermQuery s4=new SpanTermQuery(newTerm(“content”,”kk”);
SpanNearQuery query1=newSpanNearQuery(new SpanQuery[]{s1,s2},1,false);
SpanNearQuery query2=newSpanNearQuery(new SpanQuery[]{s3,s4},3,false);
SpanOrQuery query=new SpanOrQuery(newSpanQuery[]{query1,query2});
从第1个SpanQuery的查询结果中，去掉第2个SpanQuery的查询结果
SpanTermQuery s1=new SpanTermQuery(newTerm(“content”,”aa”);
SpanFirstQuery query1=newSpanFirstQuery(s1,3);
?
SpanTermQuery s3=new SpanTermQuery(newTerm(“content”,”gg”);
SpanTermQuery s4=new SpanTermQuery(newTerm(“content”,”kk”);
SpanNearQuery query2=newSpanNearQuery(new SpanQuery[]{s3,s4},4,false);
?
SpanNotQuery query=newSpanNotQuery(query1,query2);
Stringregex="http://[a-z]{1,3}//.abc//.com/.*";
???????RegexQuery query=new RegexQuery(newTerm("url",regex));
?
