转自：http://www.cnblogs.com/lvpei/articles/1732474.html
关于Lucene检索结果的排序问题。
已经知道，Lucene的默认排序是按照Document的得分进行排序的。当检索结果集中的两个Document的具有相同的得分时，默认按照Document的ID对结果进行排序。
下面研究几种设置/改变检索结果排序的方法。
■ 改变Document的boost(激励因子)
改变boost的值实现改变检索结果集的排序，是最简单的方法，只需要在建立索引的过程中，设置指定的Document的boost值，来改变排序结果中Document位置的提前或者靠后。
根据在文章 Lucene-2.2.0 源代码阅读学习(39) 中说明的关于Lucene得分的计算，实际上改变boost的大小，会导致Document的得分的改变，从而按照Lucene默认的对检索结果集的排序方式，改变检索结果中Document的排序的提前或者靠后。在计算得分的时候，使用到了boost的值，默认boost的值为1.0，也就说默认情况下Document的得分与boost的无关的。一旦改变了默认的boost的值，也就从Document的得分与boost无关，变为相关了：boost值越大，Document的得分越高。
下面这个例子在文章 Lucene-2.2.0 源代码阅读学习(39) 中测试过，这里，在建立索引的时候，设置了一下Document的boost，看看排序结果的改变情况：
package org.shirdrn.lucene.learn.sort;
import java.io.IOException;
import java.util.Date;
import net.teamhot.lucene.ThesaurusAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.search.Explanation;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.store.LockObtainFailedException;
public class AboutLuceneDefaultSort {
private String path = "F:\\index";
public void createIndex() {
IndexWriter writer;
try {
writer = new IndexWriter(path, new ThesaurusAnalyzer(), true);
Field fieldA = new Field("contents", "一人", Field.Store.YES,
Field.Index.TOKENIZED);
Document docA = new Document();
docA.add(fieldA);
docA.setBoost(0.1f); // 减小boost值
Field fieldB = new Field("contents", "一人 之交 一人之交", Field.Store.YES,
Field.Index.TOKENIZED);
Document docB = new Document();
docB.add(fieldB);
Field fieldC = new Field("contents", "一人 之下 一人之下", Field.Store.YES,
Field.Index.TOKENIZED);
Document docC = new Document();
docC.add(fieldC);
Field fieldD = new Field("contents", "一人 做事 一人当 一人做事一人当",
Field.Store.YES, Field.Index.TOKENIZED);
Document docD = new Document();
docD.setBoost(2.0f); // 提高boost值
docD.add(fieldD);
Field fieldE = new Field("contents", "一人 做事 一人當 一人做事一人當",
Field.Store.YES, Field.Index.TOKENIZED);
Document docE = new Document();
docE.add(fieldE);
writer.addDocument(docA);
writer.addDocument(docB);
writer.addDocument(docC);
writer.addDocument(docD);
writer.addDocument(docE);
writer.close();
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (LockObtainFailedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
AboutLuceneDefaultSort aus = new AboutLuceneDefaultSort();
aus.createIndex(); // 建立索引
try {
String keyword = "一人";
Term term = new Term("contents", keyword);
Query query = new TermQuery(term);
IndexSearcher searcher = new IndexSearcher(aus.path);
Date startTime = new Date();
Hits hits = searcher.search(query);
TermDocs termDocs = searcher.getIndexReader().termDocs(term);
while (termDocs.next()) {
System.out
.print("搜索关键字<" + keyword + ">在编号为 " + termDocs.doc());
System.out.println(" 的Document中出现过 " + termDocs.freq() + " 次");
}
System.out
.println("********************************************************************");
for (int i = 0; i < hits.length(); i++) {
System.out.println("Document的内部编号为 ： " + hits.id(i));
System.out.println("Document内容为 ： " + hits.doc(i));
System.out.println("Document得分为 ： " + hits.score(i));
Explanation e = searcher.explain(query, hits.id(i));
System.out.println("Explanation为 ： \n" + e);
System.out.println("Document对应的Explanation的一些参数值如下： ");
System.out.println("Explanation的getValue()为 ： " + e.getValue());
System.out.println("Explanation的getDescription()为 ： "
+ e.getDescription());
System.out
.println("********************************************************************");
}
System.out.println("共检索出符合条件的Document " + hits.length() + " 个。");
Date finishTime = new Date();
long timeOfSearch = finishTime.getTime() - startTime.getTime();
System.out.println("本次搜索所用的时间为 " + timeOfSearch + " ms");
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
如果不设置docA.setBoost(0.1f);和docD.setBoost(2.0f);，则按照默认进行排序，即boost激励因子的值为1.0，执行后，检索结果如下所示：
词库尚未被初始化，开始初始化词库.
初始化词库结束。用时:3766毫秒;
共添加195574个词语。
搜索关键字<一人>在编号为 0 的Document中出现过 1 次
搜索关键字<一人>在编号为 1 的Document中出现过 1 次
搜索关键字<一人>在编号为 2 的Document中出现过 1 次
搜索关键字<一人>在编号为 3 的Document中出现过 2 次
搜索关键字<一人>在编号为 4 的Document中出现过 2 次
********************************************************************
Document的内部编号为 ： 0
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人>>
Document得分为 ： 0.81767845
Explanation为 ：
0.81767845 = (MATCH) fieldWeight(contents:一人 in 0), product of:
1.0 = tf(termFreq(contents:一人)=1)
0.81767845 = idf(docFreq=5)
1.0 = fieldNorm(field=contents, doc=0)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.81767845
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 0), product of:
********************************************************************
Document的内部编号为 ： 3
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人 做事 一人当 一人做事一人当>>
Document得分为 ： 0.5059127
Explanation为 ：
0.5059127 = (MATCH) fieldWeight(contents:一人 in 3), product of:
1.4142135 = tf(termFreq(contents:一人)=2)
0.81767845 = idf(docFreq=5)
0.4375 = fieldNorm(field=contents, doc=3)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.5059127
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 3), product of:
********************************************************************
Document的内部编号为 ： 4
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人 做事 一人當 一人做事一人當>>
Document得分为 ： 0.5059127
Explanation为 ：
0.5059127 = (MATCH) fieldWeight(contents:一人 in 4), product of:
1.4142135 = tf(termFreq(contents:一人)=2)
0.81767845 = idf(docFreq=5)
0.4375 = fieldNorm(field=contents, doc=4)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.5059127
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 4), product of:
********************************************************************
Document的内部编号为 ： 1
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人 之交 一人之交>>
Document得分为 ： 0.40883923
Explanation为 ：
0.40883923 = (MATCH) fieldWeight(contents:一人 in 1), product of:
1.0 = tf(termFreq(contents:一人)=1)
0.81767845 = idf(docFreq=5)
0.5 = fieldNorm(field=contents, doc=1)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.40883923
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 1), product of:
********************************************************************
Document的内部编号为 ： 2
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人 之下 一人之下>>
Document得分为 ： 0.40883923
Explanation为 ：
0.40883923 = (MATCH) fieldWeight(contents:一人 in 2), product of:
1.0 = tf(termFreq(contents:一人)=1)
0.81767845 = idf(docFreq=5)
0.5 = fieldNorm(field=contents, doc=2)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.40883923
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 2), product of:
********************************************************************
共检索出符合条件的Document 5 个。
本次搜索所用的时间为 188 ms
检索结果排序为：0——3——4——1——2
如果，我们认为ID为4的Document比较重要，而ID为0的Document不重要，希望在检索的时候，ID为4的Document位置靠前一些，因为它重要，ID为0的Document靠后一些，因为它不如其它的重要，可以通过如下设置：
docA.setBoost(0.1f);
docD.setBoost(2.0f);
来改变指定的Document的boost值，从而改变这两个Document的得分，进而获取所期望的排序位置。这样设置以后，排序结果就改变了，如下所示：
词库尚未被初始化，开始初始化词库.
初始化词库结束。用时:3641毫秒;
共添加195574个词语。
搜索关键字<一人>在编号为 0 的Document中出现过 1 次
搜索关键字<一人>在编号为 1 的Document中出现过 1 次
搜索关键字<一人>在编号为 2 的Document中出现过 1 次
搜索关键字<一人>在编号为 3 的Document中出现过 2 次
搜索关键字<一人>在编号为 4 的Document中出现过 2 次
********************************************************************
Document的内部编号为 ： 3
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人 做事 一人当 一人做事一人当>>
Document得分为 ： 1.0
Explanation为 ：
1.0118254 = (MATCH) fieldWeight(contents:一人 in 3), product of:
1.4142135 = tf(termFreq(contents:一人)=2)
0.81767845 = idf(docFreq=5)
0.875 = fieldNorm(field=contents, doc=3)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 1.0118254
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 3), product of:
********************************************************************
Document的内部编号为 ： 4
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人 做事 一人當 一人做事一人當>>
Document得分为 ： 0.5
Explanation为 ：
0.5059127 = (MATCH) fieldWeight(contents:一人 in 4), product of:
1.4142135 = tf(termFreq(contents:一人)=2)
0.81767845 = idf(docFreq=5)
0.4375 = fieldNorm(field=contents, doc=4)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.5059127
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 4), product of:
********************************************************************
Document的内部编号为 ： 1
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人 之交 一人之交>>
Document得分为 ： 0.40406102
Explanation为 ：
0.40883923 = (MATCH) fieldWeight(contents:一人 in 1), product of:
1.0 = tf(termFreq(contents:一人)=1)
0.81767845 = idf(docFreq=5)
0.5 = fieldNorm(field=contents, doc=1)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.40883923
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 1), product of:
********************************************************************
Document的内部编号为 ： 2
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人 之下 一人之下>>
Document得分为 ： 0.40406102
Explanation为 ：
0.40883923 = (MATCH) fieldWeight(contents:一人 in 2), product of:
1.0 = tf(termFreq(contents:一人)=1)
0.81767845 = idf(docFreq=5)
0.5 = fieldNorm(field=contents, doc=2)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.40883923
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 2), product of:
********************************************************************
Document的内部编号为 ： 0
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人>>
Document得分为 ： 0.075761445
Explanation为 ：
0.076657355 = (MATCH) fieldWeight(contents:一人 in 0), product of:
1.0 = tf(termFreq(contents:一人)=1)
0.81767845 = idf(docFreq=5)
0.09375 = fieldNorm(field=contents, doc=0)
Document对应的Explanation的一些参数值如下：
Explanation的getValue()为 ： 0.076657355
Explanation的getDescription()为 ： fieldWeight(contents:一人 in 0), product of:
********************************************************************
共检索出符合条件的Document 5 个。
本次搜索所用的时间为 140 ms
这时，检索结果排序变为：3——4——1——2——0
可见，改变了检索结果集中Document的排序位置。
■ 改变Field的boost(激励因子)
改变Field的boost值，和改变Document的boost值是一样的。因为Document的boost是通过添加到Docuemnt中Field体现的，所以改变Field的boost值，可以改变Document的boost值。设置如下所示：
fieldA.setBoost(0.1f);
fieldD.setBoost(2.0f);
排序结果与上面设置：
docA.setBoost(0.1f);
docD.setBoost(2.0f);
对排序结果排序的改变是相同的：
3——4——1——2——0
■ 使用Sort排序工具实现排序
Lucene在查询的时候，可以通过以一个Sort作为参数构造一个检索器IndexSearcher，在构造Sort的时候，指定排序规则，例如下面的测试类：
package org.shirdrn.lucene.learn.sort;
import java.io.IOException;
import java.util.Date;
import net.teamhot.lucene.ThesaurusAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.store.LockObtainFailedException;
public class AboutLuceneSort {
private String path = "F:\\index";
public void createIndex() {
IndexWriter writer;
try {
writer = new IndexWriter(path, new ThesaurusAnalyzer(), true);
Field fieldA1 = new Field("contents", "孤身一人闯天宫，居然像旅游一下轻松，还有谁能做到这样啊？一人！", Field.Store.YES,Field.Index.TOKENIZED);
Field fieldA2 = new Field("count", "27", Field.Store.YES,Field.Index.UN_TOKENIZED);
Document docA = new Document();
docA.add(fieldA1);
docA.add(fieldA2);
Field fieldB1 = new Field("contents", "一人之交与万人之交，一人。", Field.Store.YES, Field.Index.TOKENIZED);
Field fieldB2 = new Field("count", "12", Field.Store.YES, Field.Index.UN_TOKENIZED);
Document docB = new Document();
docB.add(fieldB1);
docB.add(fieldB2);
Field fieldC1 = new Field("contents", "一人之见：千里之行，始于足下。", Field.Store.YES, Field.Index.TOKENIZED);
Field fieldC2 = new Field("count", "12", Field.Store.YES, Field.Index.UN_TOKENIZED);
Document docC = new Document();
docC.add(fieldC1);
docC.add(fieldC2);
Field fieldD1 = new Field("contents", "一人做事一人当，一人。",Field.Store.YES, Field.Index.TOKENIZED);
Field fieldD2 = new Field("count", "9", Field.Store.YES, Field.Index.UN_TOKENIZED);
Document docD = new Document();
docD.add(fieldD1);
docD.add(fieldD2);
Field fieldE1 = new Field("contents", "两人、一人、然后怎么数下去呀——晕~。",Field.Store.YES, Field.Index.TOKENIZED);
Field fieldE2 = new Field("count", "13", Field.Store.YES, Field.Index.UN_TOKENIZED);
Document docE = new Document();
docE.add(fieldE1);
docE.add(fieldE2);
writer.addDocument(docA);
writer.addDocument(docB);
writer.addDocument(docC);
writer.addDocument(docD);
writer.addDocument(docE);
writer.optimize();
writer.close();
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (LockObtainFailedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
AboutLuceneSort aus = new AboutLuceneSort();
aus.createIndex(); // 建立索引
try {
String keyword = "一人";
Term term = new Term("contents", keyword);
Query query = new TermQuery(term);
IndexSearcher searcher = new IndexSearcher(aus.path);
Date startTime = new Date();
Sort sort = new Sort("count"); // 根据名称为count的Field进行排序
Hits hits = searcher.search(query,sort);
TermDocs termDocs = searcher.getIndexReader().termDocs(term);
while (termDocs.next()) {
System.out
.print("搜索关键字<" + keyword + ">在编号为 " + termDocs.doc());
System.out.println(" 的Document中出现过 " + termDocs.freq() + " 次");
}
System.out
.println("********************************************************************");
for (int i = 0; i < hits.length(); i++) {
System.out.println("Document的内部编号为 ： " + hits.id(i));
System.out.println("Document内容为 ： " + hits.doc(i));
System.out.println("Document得分为 ： " + hits.score(i));
for(int j=0;j<hits.doc(i).getFields().size();j++){
Field field = (Field)hits.doc(i).getFields().get(j);
System.out.println("--- ---Field的name为 ： " + field.name());
System.out.println("--- ---Field的StringValue为 ： " + field.stringValue());
}
System.out.println("********************************************************************");
}
System.out.println("共检索出符合条件的Document " + hits.length() + " 个。");
Date finishTime = new Date();
long timeOfSearch = finishTime.getTime() - startTime.getTime();
System.out.println("本次搜索所用的时间为 " + timeOfSearch + " ms");
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
使用了Sort类的一个只有一个参数的构造方法：
public final void setSort(String field) {
setSort(field, false);
}
可见，实际上调用了 setSort(field, false);方法，第一个field为指定一个Field的名称，按照给Field进行排序，第二个为boolean型值，该值指定是否按照降序进行排序，默认情况下为false，表示按照升序排序，即如果按照指定的field排序是作为第一排序的，而且是按照升序排序的，第二排序默认按照Document的ID号码(编号)进行升序排序。
setSort(field, false)方法定义：
public void setSort(String field, boolean reverse) {
SortField[] nfields = new SortField[] {
new SortField(field, SortField.AUTO, reverse), SortField.FIELD_DOC };
fields = nfields;
}
在setSort(field, false)方法中，可以看到，实际上使用了SortField类实现了排序，SortField类具有更加丰富的关于排序的规则和内容。
指定：根据Field名称为“count”进行排序，这里，count是字数的意思，因此在分词的时候没有对其进行分词。期望的排序结果是，根据count，即字数进行排序，而不是根据Document的得分来排序。
运行结果如下所示：
词库尚未被初始化，开始初始化词库.
初始化词库结束。用时:3656毫秒;
共添加195574个词语。
搜索关键字<一人>在编号为 0 的Document中出现过 1 次
搜索关键字<一人>在编号为 1 的Document中出现过 1 次
搜索关键字<一人>在编号为 2 的Document中出现过 1 次
搜索关键字<一人>在编号为 3 的Document中出现过 1 次
搜索关键字<一人>在编号为 4 的Document中出现过 1 次
********************************************************************
Document的内部编号为 ： 3
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人做事一人当，一人。> stored/uncompressed,indexed<count:9>>
Document得分为 ： 0.51104903
--- ---Field的name为 ： contents
--- ---Field的StringValue为 ： 一人做事一人当，一人。
--- ---Field的name为 ： count
--- ---Field的StringValue为 ： 9
********************************************************************
Document的内部编号为 ： 1
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人之交与万人之交，一人。> stored/uncompressed,indexed<count:12>>
Document得分为 ： 0.35773432
--- ---Field的name为 ： contents
--- ---Field的StringValue为 ： 一人之交与万人之交，一人。
--- ---Field的name为 ： count
--- ---Field的StringValue为 ： 12
********************************************************************
Document的内部编号为 ： 2
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:一人之见：千里之行，始于足下。> stored/uncompressed,indexed<count:12>>
Document得分为 ： 0.40883923
--- ---Field的name为 ： contents
--- ---Field的StringValue为 ： 一人之见：千里之行，始于足下。
--- ---Field的name为 ： count
--- ---Field的StringValue为 ： 12
********************************************************************
Document的内部编号为 ： 4
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:两人、一人、然后怎么数下去呀——晕~。> stored/uncompressed,indexed<count:13>>
Document得分为 ： 0.25552452
--- ---Field的name为 ： contents
--- ---Field的StringValue为 ： 两人、一人、然后怎么数下去呀——晕~。
--- ---Field的name为 ： count
--- ---Field的StringValue为 ： 13
********************************************************************
Document的内部编号为 ： 0
Document内容为 ： Document<stored/uncompressed,indexed,tokenized<contents:孤身一人闯天宫，居然像旅游一下轻松，还有谁能做到这样啊？一人！> stored/uncompressed,indexed<count:27>>
Document得分为 ： 0.20441961
--- ---Field的name为 ： contents
--- ---Field的StringValue为 ： 孤身一人闯天宫，居然像旅游一下轻松，还有谁能做到这样啊？一人！
--- ---Field的name为 ： count
--- ---Field的StringValue为 ： 27
********************************************************************
共检索出符合条件的Document 5 个。
本次搜索所用的时间为 125 ms
可见，是按照字数count来进行排序的：9——12——12——13——27
而此时检索结构的对应的得分分别为：0.51104903——0.35773432——0.40883923——0.25552452——0.20441961
可见，并不是按照得分的情况来进行排序的，而且，如果count的值相等，则使用默认的第二排序规则，即按照Document的ID号来排序，从上面的count=12结果可以看出。
关于Sort类，在其内部定义了6种构造方法：
public Sort()
public Sort(SortField field)
public Sort(SortField[] fields)
public Sort(String field)
public Sort(String field, boolean reverse)
public Sort(String[] fields)
可以根据不同需要指定排序的规则，按照某个或某几个Field进行排序。不带参数的构造方法public Sort()，在实例化一个Sort之后，可以非常方便的通过调用setSort方法设定排序规则，setSort有5个重载的方法：
public void setSort(SortField field)
public void setSort(SortField[] fields)
public final void setSort(String field)
public void setSort(String field, boolean reverse)
public void setSort(String[] fieldnames)
当然，public final void setSort(String field)在外部不允许直接调用了，是默认的内部使用的设置排序规则的方法。
■ 直接使用SortField实现排序
首先看一下SortField类的源代码：
package org.apache.lucene.search;
import java.io.Serializable;
import java.util.Locale;
public class SortField
implements Serializable {
// 按照Document的得分对检索结果进行排序，得分高的排序靠前
public static final int SCORE = 0;
// 按照Document的编号(ID)对检索结果进行排序，编号小的排序靠前
public static final int DOC = 1;
// 自动检测，自动选择最佳的排序方式，即按照整数类型
public static final int AUTO = 2;
// 根据词条的String串排序
public static final int STRING = 3;
// 将词条解码为整数，按照整数排序
public static final int INT = 4;
// 将词条解码为浮点数，按照浮点数排序
public static final int FLOAT = 5;
// 根据定制的排序器，实现客户化排序
public static final int CUSTOM = 9;
// IMPLEMENTATION NOTE: the FieldCache.STRING_INDEX is in the same "namespace"
// as the above static int values. Any new values must not have the same value
// as FieldCache.STRING_INDEX.
/** 根据Document的得分构造一个SortField实例 */
public static final SortField FIELD_SCORE = new SortField (null, SCORE);
/** 根据Document的编号构造一个SortField实例 */
public static final SortField FIELD_DOC = new SortField (null, DOC);
private String field;
private int type = AUTO; // defaults to determining type dynamically
private Locale locale; // defaults to "natural order" (no Locale)
boolean reverse = false; // defaults to natural order
private SortComparatorSource factory;
//★ 下面定义了8种构造SortField的方法 ★
// 以一个Field的名字的Sing串作为参数构造一个SortField
public SortField (String field) {
this.field = field.intern();
}
public SortField (String field, boolean reverse) {
this.field = field.intern();
this.reverse = reverse;
}
public SortField (String field, int type) {
this.field = (field != null) ? field.intern() : field;
this.type = type;
}
public SortField (String field, int type, boolean reverse) {
this.field = (field != null) ? field.intern() : field;
this.type = type;
this.reverse = reverse;
}
public SortField (String field, Locale locale) {
this.field = field.intern();
this.type = STRING;
this.locale = locale;
}
public SortField (String field, Locale locale, boolean reverse) {
this.field = field.intern();
this.type = STRING;
this.locale = locale;
this.reverse = reverse;
}
public SortField (String field, SortComparatorSource comparator) {
this.field = (field != null) ? field.intern() : field;
this.type = CUSTOM;
this.factory = comparator;
}
public SortField (String field, SortComparatorSource comparator, boolean reverse) {
this.field = (field != null) ? field.intern() : field;
this.type = CUSTOM;
this.reverse = reverse;
this.factory = comparator;
}
public String getField() {
return field;
}
public int getType() {
return type;
}
public Locale getLocale() {
return locale;
}
public boolean getReverse() {
return reverse;
}
public SortComparatorSource getFactory() {
return factory;
}
public String toString() {
StringBuffer buffer = new StringBuffer();
switch (type) {
case SCORE: buffer.append("<score>");
break;
case DOC: buffer.append("<doc>");
break;
case CUSTOM: buffer.append ("<custom:\"" + field + "\": "
+ factory + ">");
break;
default: buffer.append("\"" + field + "\"");
break;
}
if (locale != null) buffer.append ("("+locale+")");
if (reverse) buffer.append('!');
return buffer.toString();
}
}
从上面代码中，可以看出，指定了一种排序的type，这个type对排序的效率是至关重要的，涉及到一个比较的问题。从代码中：
private int type = AUTO;
指定了默认的类型，而AUTO定义如下：
public static final int AUTO = 2;
即按照整数类型，使用整数类型作为排序的type，在进行排序时，效率远远比String类型要高得多。
构造一个SortField实例之后，通过Sort类的setSort方法可以设定详细的排序规则，从而实现对检索结果的排序。
例如：
1、构造一个没有参数的Sort：Sort sort = new Sort();
2、构造一个SortField：SortField sf = new SortField("count",SortField.AUTO,true);
3、使用setSort方法：sort .setSort(sf);
4、构造一个检索器：IndexSearcher is = new IndexSearcher("F:\\index");
5、调用带Sort参数的search检索方法：Hits hits = is.search(query,sort);
这是一个最简单的设置排序的步骤，可以根据SortField的构造方法，构造更加复杂的排序规则。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
