摘要：序本文主要記錄一下的另外兩個要點的使用查詢與排序。在指定距離可以找到第一個單詞的查詢。查詢的幾個語句之間保持者一定的距離。同時查詢幾個詞句查詢。從一個詞距查詢結果中，去除一個詞距查詢。

本文主要記錄一下lucene的另外兩個要點的api使用：查詢與排序。

   /**
     * 查找指定field中包含某個關鍵字
     * @throws IOException
     */
    @Test
    public void termQuery() throws IOException {
        String field = "title";
//        String queryStr = "in";
//        String queryStr = "Lucene in Action";
//        String queryStr = "action";
        String queryStr = "lucene";
        Term term = new Term(field,queryStr);
        Query query = new TermQuery(term);
        executeQuery(query);
    }

 /**
     * 查找指定字段中包含與關鍵字相似的文檔
     * 查詢用于匹配與指定項相似的項
     * 編輯距離算法，兩個字符串之間相似度的一個度量方法
     * 用來決定索引文件中的項與指定目標項的相似程度.
     * 取所有相同前綴(前綴長度可以設定)的詞項做編輯距離
     *
     * 編輯距離實際上是表明兩個不同的字符串需要經過多少次編輯和變換才能變為對方。
     * 通常的編輯行為包括了增加一個檢索項，刪除一個檢索項，修改一個檢索項，
     * 與普通的字符串匹配函數不同，模糊搜索里的編輯距離是以索引項為單位的。
     *
     * http://www.xinxilong.com/html/?2481.html
     * @throws IOException
     */
    @Test
    public void fuzzyQuery() throws IOException {
        String field = "title";
        String queryStr = "act";// 自動在結尾添加 ~ ,即查詢act~
        Term term = new Term(field,queryStr);
        int maxEdits = 1;  //編輯距離最多不能超過多少
        int prefixLength = 3; //相同的前綴長度
//        Query query = new FuzzyQuery(term,maxEdits,prefixLength);
        Query query = new FuzzyQuery(term,maxEdits);
//        Query query = new FuzzyQuery(term);
        executeQuery(query);
    }

/**
     * http://my.oschina.net/MrMichael/blog/220694
     * 同一個關鍵詞多個字段搜索
     * 用MultiFieldQueryParser類實現對同一關鍵詞的跨域搜索
     */
    @Test
    public void multiFieldQueryCrossFields() throws ParseException, IOException {
        String[] fields = new String[]{"title","desc"};
        String queryStr = "good";
        Map boosts = new HashMap();
        //設定它們在搜索結果排序過程中的權重，權重越高，排名越靠前
        boosts.put("title", 1.0f);
        boosts.put("desc", 0.7f);
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, new StandardAnalyzer(),boosts);
        Query query = parser.parse(queryStr);
        executeQuery(query);
    }

/**
     * 使用多個關鍵字,及多個field進行查詢
     */
    @Test
    public void multiFieldQueryMultiKeyword() throws ParseException, IOException {
        String[] queries = {"good","lucene"};
        String[] fields = {"title","desc"};
        BooleanClause.Occur[] clauses = {BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD};
        Query query = MultiFieldQueryParser.parse(queries,fields,clauses,new StandardAnalyzer());
        executeQuery(query);
    }

/**
     * 通配符查詢
     * 星號*:代表0個或多個字母
     * 問號?:代表0個或1個字母
     */
    @Test
    public void wildcardQuery() throws IOException {
        String field = "title";
//        String queryStr = "*pute?";
        String queryStr = "act*";
        Term term = new Term(field,queryStr);
        Query query = new WildcardQuery(term);
        executeQuery(query);
    }

   /**
     * 前綴查詢
     * 自動在關鍵詞末尾添加*
     */
    @Test
    public void prefixQuery() throws IOException {
        String field = "title";
        String queryStr = "act"; //act*
        Term term = new Term(field,queryStr);
        Query query = new PrefixQuery(term);
        executeQuery(query);
    }

/**
     * http://blog.csdn.net/rick_123/article/details/6708527
     * 短語查詢,對關鍵詞加引號,通過位置移動來匹配
     * slop的概念：slop是指兩個項的位置之間允許的最大間隔距離
     * 例如:slop設置為1,則 quick brown fox 可以匹配 quick fox
     */
    @Test
    public void phraseQuery() throws IOException {
        Query query = new PhraseQuery.Builder()
                .setSlop(3)
                .add(new Term("title", "computer"))
                .add(new Term("title","art"))
                .build();
        executeQuery(query);
    }

/**
     * http://callan.iteye.com/blog/154251
     * 跨度查詢,用于查詢多個詞的時候考慮幾個詞在文檔中的匹配位置
     * 與phraseQuery和multiFieldQuery很相似,都是通過位置限制匹配
     * 但是spanQuery更加靈活
     *
     * SpanQuery包括以下幾種：
     * SpanTermQuery：詞距查詢的基礎，結果和TermQuery相似，只不過是增加了查詢結果中單詞的距離信息。
     * SpanFirstQuery：在指定距離可以找到第一個單詞的查詢。
     * SpanNearQuery：查詢的幾個語句之間保持者一定的距離。
     * SpanOrQuery：同時查詢幾個詞句查詢。
     * SpanNotQuery：從一個詞距查詢結果中，去除一個詞距查詢。
     */
    @Test
    public void spanQuery() throws IOException {
        SpanTermQuery query = new SpanTermQuery(new Term("title","art"));
        executeQuery(query);
    }

    /**
     * 第一次出現在指定位置
     * @throws IOException
     */
    @Test
    public void spanFirstQuery() throws IOException {
        SpanTermQuery query = new SpanTermQuery(new Term("title","art"));
        SpanFirstQuery spanFirstQuery =new SpanFirstQuery(query,2); //出現在第2個位置
        executeQuery(spanFirstQuery);
    }

    /**
     * SpanNearQuery中將SpanTermQuery對象作為SpanQuery對象使用的效果，與使用PharseQuery的效果非常相似。
     * 最大的區別是：在SpanNearQuery的構造函數中的第三個參數為inOrder標志，設置這個標志為true，項添加的順序和其文檔中出現的順序相同
     */
    @Test
    public void spanNearQuery() throws IOException {
        SpanTermQuery queryScience = new SpanTermQuery(new Term("title","science"));
        SpanTermQuery queryArt = new SpanTermQuery(new Term("title","art"));
        SpanQuery[] queries = new SpanQuery[]{queryScience,queryArt};
        int slop = 2;//science 與 art兩個詞間隔在2以內
        boolean inOrder = false;//不需要按數組中的順序出現在文檔中
        SpanNearQuery query = new SpanNearQuery(queries,slop,inOrder);
        executeQuery(query);
    }

    @Test
    public void spanOrQuery() throws IOException {
        SpanTermQuery queryScience = new SpanTermQuery(new Term("title","science"));
        SpanTermQuery queryArt = new SpanTermQuery(new Term("title","art"));
        SpanQuery[] queries = new SpanQuery[]{queryScience,queryArt};
        int slop = 2;//science 與 art兩個詞間隔在2以內
        boolean inOrder = false;//不需要按數組中的順序出現在文檔中
        SpanNearQuery spanNearQuery = new SpanNearQuery(queries,slop,inOrder);

        SpanTermQuery queryComputer = new SpanTermQuery(new Term("title","lucene"));

        SpanOrQuery query = new SpanOrQuery(new SpanQuery[]{spanNearQuery,queryComputer});
        executeQuery(query);
    }

/**
     * 組合查詢
     * MUST與MUST組合表示并集
     * MUST與MUST_NOT表示包含與不包含
     * MUST_NOT與MUST_NOT組合沒有意義
     * SHOULD與SHOULD組合表示或
     * SHOULD與MUST表示MUST,其中SHOULD沒有任何價值
     * SHOULD與MUST_NOT相當于MUST與MUST_NOT表示包含與不包含
     */
    @Test
    public void booleanQuery() throws IOException {
        TermQuery queryComputerInTitle = new TermQuery(new Term("title","computer"));
        TermQuery queryGoodInDesc = new TermQuery(new Term("desc","good"));

        BooleanQuery booleanQuery = new BooleanQuery.Builder()
                .add(queryComputerInTitle,BooleanClause.Occur.SHOULD)
                .add(queryGoodInDesc,BooleanClause.Occur.SHOULD)
                .setMinimumNumberShouldMatch(1)
                .build();
        executeQuery(booleanQuery);
    }

/**
     * 按指定字段排序
     * @throws IOException
     * @throws ParseException
     */
    @Test
    public void sortByField() throws IOException, ParseException {
        //Sort using term values as encoded Integers.  Sort values are Integer and lower values are at the front.
        boolean isReverse = false;
        SortField sortField = new SortField("title", SortField.Type.STRING,isReverse);
        Query query = new TermQuery(new Term("title","lucene"));
        Sort sort = new Sort(sortField);
        executeQuery(query, sort);
    }

   /**
     * 按索引順序排序
     * @throws IOException
     */
    @Test
    public void sortByIndexOrder() throws IOException {
        Query query = new TermQuery(new Term("title","lucene"));
        executeQuery(query,Sort.INDEXORDER);
    }

/**
     * 按文檔的得分排序
     * @throws IOException
     */
    @Test
    public void sortByRelevance() throws IOException {
        TermQuery queryComputerInTitle = new TermQuery(new Term("title","computer"));
        TermQuery queryGoodInDesc = new TermQuery(new Term("desc","good"));

        BooleanQuery query = new BooleanQuery.Builder()
                .add(queryComputerInTitle,BooleanClause.Occur.SHOULD)
                .add(queryGoodInDesc,BooleanClause.Occur.SHOULD)
                .setMinimumNumberShouldMatch(1)
                .build();
        executeQuery(query,Sort.RELEVANCE);
    }

本工程github

細說 lucene的fuzzyquery和wildcardquery

lucene4下用MultiFieldQueryParser同時搜索多個field時

對Lucene PhraseQuery的slop的理解

lucene的多種搜索2-SpanQuery