0

我有一个类 Arraylist 包含值字符串字，字符串扩展字，双重信心，双重支持

我想根据置信度对数组列表进行排序，然后根据支持度。

我已经成功地根据信心对数组列表进行了排序，但是我没有制定一种新的方法来根据支持对数组列表进行排序

这是我根据信心对其进行排序的代码

public class ExpandedTerm implements Comparable<ExpandedTerm> {
String word;
String expandedWord;
double support;
double confidence;

public ExpandedTerm (String word,String expandedWord, double confidence,double support){
    this.word = word;
    this.expandedWord = expandedWord;
    this.support = support;
    this.confidence = confidence;
}

public String getWord(){
    return word;
}

public String expandedWord(){
    return expandedWord;
}

public Double getSupport(){
    return support;
}

public Double getConfidence(){
    return confidence;
}

@Override
public int compareTo(ExpandedTerm conf) {
    return new Double(this.confidence).compareTo(new Double(conf.confidence));
}

我未能制作另一种方法，如 compareTo，根据支持值对其进行排序。如何先按置信度排序，然后再用另一种方法按支持度值排序？

4

3 回答 3

3

用户比较器。作为可比提供的功能，可以在单一类型的基础上进行排序。这是您发现何时使用可比较和 comapartor
http://iandjava.blogspot.in/2012/10/comparable-and-comparator.html的链接

使用多个比较器

  • 一个信心

    public class ConfidanceComparator implements Comparator<ExpandedTerm> {
        @Override
        public int compare(final ExpandedTerm  o1, final ExpandedTerm  o2) {
            return new Double(o1.confidence).compareTo(new Double(o2.confidence));
        }
    }
  • 一个支持

    public class SupportComparator implements Comparator<ExpandedTerm> {
        @Override
        public int compare(final ExpandedTerm  o1, final ExpandedTerm  o2) {
            return new Double(o1.support).compareTo(new Double(o2.support));
        }
    }

并使用Collections.sort(<List>, <comparator>)adn 您将获得所需的列表。

仅当您要在信任基础或支持基础上进行排序时，才需要这样做。
但是，如果您需要，则首先按信任度排序，如果信任度相等，则检查支持度。那么可比较就足够了，并且是

public int compareTo(ExpandedTerm conf) {
    int compare = new Double(this.confidence).compareTo(new Double(conf.confidence));

    if (compare == 0) {
        compare = new Double(this.support).compareTo(new Double(conf.support));
    }
    return compare;
}
于 2013-07-11T04:09:58.483 回答
1

为您的 compareTo 方法尝试以下代码：

@Override
public int compareTo(ExpandedTerm other) {
    Double thisConfidence = new Double(getConfidence());
    Double otherConfidence = new Double(other.getConfidence());
    int compare = thisConfidence.compareTo(otherConfidence);

    if (compare == 0) {
        Double thisSupport = new Double(getSupport());
        Double otherSupport = new Double(other.getSupport());
        compare = thisSupport.compareTo(otherSupport);
    }
    return compare;
}

如果“信心”相等，基本上只比较“支持”。

于 2013-07-11T04:15:13.863 回答
0

我看到你的回复说你想排序一次然后再排序一次，所以我假设你想在排序时添加一个自定义比较器。这是你要找的吗？

public static void main(String[] args) {
    ExpandedTerm term1 = new ExpandedTerm("a", "b", 1, 4);
    ExpandedTerm term2 = new ExpandedTerm("c", "d", 3, 2);

    List<ExpandedTerm> list = new ArrayList();
    list.add(term1);
    list.add(term2);

    Collections.sort(list);
    System.out.println(list);

    Collections.sort(list, new Comparator<ExpandedTerm>() {
        @Override
        public int compare(ExpandedTerm o1, ExpandedTerm o2) {
            return new Double(o2.confidence).compareTo(new Double(o1.confidence));
        }
    });
    System.out.println(list);
}

这是输出

[ExpandedTerm@2eeb3c84, ExpandedTerm@55d2162c]
[ExpandedTerm@55d2162c, ExpandedTerm@2eeb3c84]

其他一些提示：确保为 ExpandedTerm 实现了 toString()、hashCode() 和 equals() 函数。这些对于调试以及在其他集合（如 HashMap 等）中的使用都是必不可少的。

于 2013-07-11T05:13:00.263 回答