我搜索出的产品过多，想对其做折叠功能。就是同个公司的产品只显示一个，并计算重复的产品个数。
    不知道用Lucene有什么好的思路可以实现？
    或者需要在Lucene外面实现？
    下面是实例：
    productID     companyId     score       userGrade
    1                1                  0.7898      10
    2                1                  0.7823      10
    3                1                  0.7811      10
    4                2                  0.7900      10
    5                2                  0.7650      10
    6                2                  0.7655      10
    7                3                  0.7922      0
我的排序语句：
new SortField("userGrade", true), SortField.FIELD_SCORE
确保userGrade为10的排前面，一样为10的score高的排前面

排序结果：
    productID     companyId     score       userGrade
    4                2                  0.7900      10
    1                1                  0.7898      10
    2                1                  0.7823      10
    3                1                  0.7811      10
    6                2                  0.7655      10
    5                2                  0.7650      10
    7                3                  0.7922      0

想要的结果：
    productID     companyId     score       userGrade
    4                2                  0.7900      10
    1                1                  0.7898      10
    7                3                  0.7922      0
目前我达到上面结果是通过对companyId遍历，没出现放到Map里面，出现过++
很傻的方法，各位见笑，也麻烦大家多多提点。

如果能通过排序达到：确保userGrade相同时，相同companyId被排在一起，
其中最高的score决定companyId的排列顺序，如下图，这样通过遍历可以
少算很多，呵呵～～～
    productID     companyId     score       userGrade
    4                2                  0.7900      10
    6                2                  0.7655      10
    5                2                  0.7650      10
    1                1                  0.7898      10
    2                1                  0.7823      10
    3                1                  0.7811      10
    7                3                  0.7922      0

周末开心～～大家

做法很多！ filter 可以解决你所有问题！  仔细看下自定义的filter，记得使用fieldcache 很好做的

import org.apache.lucene.index.IndexReader;
import org.apache.lucene.search.FieldCache;
import org.apache.lucene.search.Filter;

import java.util.BitSet;
import java.io.IOException;


public class CompanyProductFilter extends Filter {
    public BitSet bits(IndexReader reader) throws IOException {

        BitSet bitSet = new BitSet(reader.maxDoc());
        int companyIds[] = FieldCache.DEFAULT.getInts(
                reader,
                "company_id"
        );
        /* 为了确定是否有该公司的东西出现了 */
        BitSet companyIdSet = new BitSet(getMaxInt(companyIds));

        for (int i = 0; i < companyIds.length; i++) {
            /* 该公司没出现 */
            if (!companyIdSet.get(companyIds[i])){    
                /*我这里是帮你将同一个公司的第一个以后的过滤了，这个地方想怎么做，自己可以设计的*/
                bitSet.set(i);
                companyIdSet.set(companyIds[i]);
                /*设置，现在该公司的产品出现了*/
            }
        }    
        return bitSet;
    }

    static int getMaxInt(int num[]) {
        int max = num[0];
        for (int i = 1; i < num.length; i++)
            max = max > num[i] ? max : num[i];
        return max;
    }
}

帮你实现好了，自己可以看看，看是不是满足你的需求   ：）

用的时候用对象池会更完美，我就不帮你改了

to:moshalanye
谢谢这位兄弟了，我好好看看～～～
有什么不懂再问你～～

    那个计算重复产品，也在filter里面做，用翻转放在哪个对象中，你可以自己控制，我这边只给了你个做法

十分感谢～～
用反转？
我想想先～～

这样做不会遇到http://www.iteye.com/problems/56767　问题吗？？？