3

我有一系列需要按规则订购的对象。但是我需要能够切换规则，但是我有一组有限的排序规则。哪种数据结构是最好的选择？

作为一个例子，我有这个类：

class Test {
    public final int amount;
    public final int cost;
    public final String name;
    public final int whatever;
    // ...

    // TODO: add a constructor to set the fields :-)
}

我如何存储这些字段以按金额、成本、名称或其他方式对它们进行排序。但只是其中一个规则。

我可以想象使用 anArrayList或 aHashSet来调用排序函数和 custom Comparator。但我无法想象这就是效率。我认为这在移动设备上很重要。有什么更好的方法来实现这一目标？

4

5 回答 5

5

您不能使用 anSet进行排序，因为它没有任何顺序。每一个拥有List和定制的概念是如何Comparator<T>合理的。

您应该采用该解决方案，此时不要关心性能。如果您对获得的结果不满意，请尝试提出更好的解决方案。

最好的解决方案是以正确的顺序从存储中读取数据。我不知道你的应用程序商店的结构如何。因此，我无法帮助您。但是实施类似的解决方案，您会发现情况还不错。

在移动设备上重要的是内存使用。如果您的应用程序将使用大量这些排序操作，您可以将比较器创建为枚举，这样它们只会被加载一次，此外还可以简化代码

private enum  TestComparator implements Comparator<Test> {
 BY_NAME {

    @Override
    public int compare(Test o1, Test o2) {

       //We validate first against null

       return o1n.name.compareTo(o2.name);

    }               
  }
 BY_WHATEVER{

    @Override
    public int compare(Test o1, Test o2) {

       //We validate first against null
      return (o1.whatever<o2.whatever ? -1 : (o1.whatever==o2.whatever ? 0 : 1));
    }               
  }

}
于 2012-11-21T07:46:30.137 回答
3

做这个：

class Test {
public final int amount;
public final int cost;
public final String name;
public final int whatever;
// ...

// TODO: add a constructor to set the fields :-)

    class TestAmountComparator implements Comparator<Test> {
        @Override
        public int compare(Test t1, Test t2) {
            return Integer.valueOf(t1.amount).compareTo(Integer.valueOf(t2.amount))          
        }
    }

    class TestCostComparator implements Comparator<Test> {
        @Override
        public int compare(Test t1, Test t2) {
            return Integer.valueOf(t1.cost).compareTo(Integer.valueOf(t2.cost))          
        }
    }

}

将您的 Test 对象存储在ArrayList（或任何其他集合）中，然后以这种方式对它们进行排序：

List<Test> list = new ArrayList<Test>(myTest); //your Test list
//sorting
Collections.sort(list, new TestAmountComparator()); //sort by amount
Collections.sort(list, new TestCostComparator()); //sort by cost
于 2012-11-21T07:56:15.740 回答
1

我的版本：

class Test3 implements Comparable<Test3> {
    public int amount;
    //...

    Comparator<Test3> comparator;

    public void setComparator(Comparator<Test3> comparator) {
        this.comparator = comparator;
    }

    @Override
    public int compareTo(Test3 o) {
        return comparator.compare(this, o);
    }
}
于 2012-11-21T08:24:50.963 回答
1

我宁愿实现Comparable 接口并在类中实现compareTo方法。它提供了跨不同数据结构排序的一致性行为。在这种情况下，仅当需要特殊排序时才会使用Comparator 接口。

class Test implements Comparable {
    public final int amount;
    public final int cost;
    public final String name;
    public final int whatever;
    // ...
    //add equals ,hashcode, and compareTo method in the class...
    // TODO: add a constructor to set the fields :-)
}

如果实例是唯一的并且实现了可比较，则可以使用 TreeSet。否则，您必须使用列表并使用 Collection.sort 函数对它们进行排序。

您可以根据访问使用情况来决定 DS。如果要按顺序访问元素，请使用 LinkedList 否则用户 ArrayList

于 2012-11-21T08:02:11.647 回答
0

这就是我们如何在不丢失重复项的情况下使用 TreeSet：

import java.util.Comparator;
import java.util.TreeSet;

    public class Test {
        int amount;

        Test(int amount) {
            this.amount = amount;
        }

        public static void main(String args[]) throws Exception {
            Comparator<Test> c = new Comparator<Test>() {
                @Override
                public int compare(Test o1, Test o2) {
                    if (o1.amount >= o2.amount) {
                        return 1;
                    }
                    return -1;
                }
            };
            TreeSet<Test> s = new TreeSet<Test>(c);
            s.add(new Test(2));
            s.add(new Test(1));
            s.add(new Test(1));
            for (Test t : s) {
                System.out.println(t.amount);
            }

        }
    }

这打印：

1
1
2
于 2012-11-21T09:24:15.640 回答