Lucene 排序 Sort与SortField

在sql语句中，有升序和降序排列。在Lucene中，同样也有。

Sort里的属性	SortField里的属性	含义
Sort.INDEXORDER	SortField.FIELD_DOC	按照索引的顺序进行排序
Sort.RELEVANCE	SortField.FIELD_SCORE	按照关联性评分进行排序

=========SortField类============
//field是排序字段type是排序类型
public SortField(String field, Type type);
//field是排序字段type是排序类型reverse是指定升序还是降序
//reverse 为true是降序  false为升序
public SortField(String field, Type type, boolean reverse)

=========Sort类============
public Sort();//Sort对象构造方法默认是按文档评分排序
public Sort(SortField field);//排序的一个SortField
public Sort(SortField... fields)//排序的多个SortField可以传入一个数组

前提，创建索引：

 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
 import java.nio.file.Paths;
 import java.util.Random;

 import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.document.IntField;
 import org.apache.lucene.document.LongField;
 import org.apache.lucene.document.NumericDocValuesField;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.FSDirectory;

 public class FileIndexUtils {
     private static Directory directory = null;
     static{
         try {
             directory = FSDirectory.open(Paths.get("D://lucene//document"));
         } catch (Exception e) {
             // TODO: handle exception
             e.printStackTrace();
         }
     }
     public static Directory getDirectory(){
         return directory;
     }
     /**
      * 创建索引
      * @param hasNew
      */
     @SuppressWarnings("deprecation")
     public static void createIndex(boolean hasNew){
         IndexWriter writer = null;
         try {
             writer = new IndexWriter(directory, new IndexWriterConfig(new StandardAnalyzer()));
             if(hasNew){
                 writer.deleteAll();
             }

             Document document = null;
             int index = 0;
             //随机数，为排序数字
             Random random = new Random();
             //为源文件创建索引
             File file = new File("D://text");
             for(File f:file.listFiles()){
                 int score = random.nextInt();
                 document = new Document();
                 document.add(new Field("id",String.valueOf(index++), Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
                 document.add(new Field("content",new FileReader(f)));
                 document.add(new Field("fileName",f.getName(),Field.Store.YES,Field.Index.NOT_ANALYZED));
                 document.add(new Field("path",f.getPath(),Field.Store.YES,Field.Index.NOT_ANALYZED));
                 document.add(new IntField("score",score,Field.Store.YES));
                 document.add(new NumericDocValuesField("size",(long)f.length()));
                 document.add(new LongField("size", f.length(), Field.Store.YES));
                 document.add(new IntField("date",(int) f.lastModified(),Field.Store.YES));
                 writer.addDocument(document);
             }
         } catch (Exception e) {
             // TODO: handle exception
             e.printStackTrace();
         }finally{
             if(writer!=null){
                 try {
                     writer.close();
                 } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         }
     }
 }

一，Sort排序

getSearcher（）

 private static IndexReader reader = null;
     static{
         try {
             reader = DirectoryReader.open(FileIndexUtils.getDirectory());
         } catch (Exception e) {
             // TODO: handle exception
             e.printStackTrace();
         }
     }

     public IndexSearcher getSearcher(){
         try {
             if(reader == null){
                 reader = DirectoryReader.open(FileIndexUtils.getDirectory());
             }else{
                 IndexReader tr = DirectoryReader.openIfChanged((DirectoryReader) reader);
                 if(tr!=null) {
                     reader.close();
                     reader = tr;
                 }
             }
             return new IndexSearcher(reader);
         } catch (Exception e) {
             // TODO: handle exception
             e.printStackTrace();
         }
         return null;
     }

   /**
     * 排序Sort
     * @param queryStr
     * @param sort
     */
    public void searcherBySort(String queryStr,Sort sort) {
        try {
            IndexSearcher searcher = getSearcher();
            QueryParser parser = new QueryParser("content",new StandardAnalyzer());
            Query query = parser.parse(queryStr);
            TopDocs tds = null;
            if(sort!=null)
                tds = searcher.search(query, 50, sort);
            else {
                tds = searcher.search(query, 50);
            }
            for(ScoreDoc sd:tds.scoreDocs) {
                Document d = searcher.doc(sd.doc);
                System.out.println(sd.doc+":("+sd.score+")" +
                        "["+d.get("fileName")+"【"+d.get("path")+"】---"+d.get("score")+"--->"+
                        Integer.valueOf(d.get("size"))/1024+"-----");
            }

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

测试：

    @Test
    public void test01(){
        st.searcherBySort("select",Sort.RELEVANCE);
        System.out.println("------------");
        st.searcherBySort("select",null);
    }

二、SortField

/**
     * 排序SortField
     * @param sortField
     * @param reverse
     */
    public void searcherBySortField(String filename,boolean reverse){
        try {
            IndexSearcher searcher = getSearcher();
            SortField sortField = new SortField(filename,SortField.Type.LONG,reverse);
            Sort sort = new Sort(sortField);

            TopDocs tds = searcher.search(new MatchAllDocsQuery(),100,sort);
            for(ScoreDoc sd:tds.scoreDocs){
                Document d = searcher.doc(sd.doc);
                System.out.println("["+d.get("fileName")+"]【"+d.get("path")+"】---score:"+d.get("score")+"--->"+"size:"+d.get("size"));
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{
            try {
                if(reader!=null){
                    reader.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

测试：

    @Test
    public void test02(){
        st.searcherBySortField("size", false);
        System.out.println("------------");
    }

size根据大小排序。