1

这是我到目前为止所拥有的，我正在尝试根据索引的值对一堆List<String>'进行排序。

LinkedHashSet<List<String>> sorted = new LinkedHashSet<List<String>>();

如何按列表的从最高到最低索引 2 值的顺序对 LinkedHashSet 进行排序？

示例输入：

List<String> data1 = Database.getData(uuid);
double price = Double.valueOf(data1.get(2))

data1.add("testval");
data1.add("testval");
data1.add("100.00");

sorted.add(data1);

在另一个单独的列表中：

List<String> data2 = Database.getData(uuid);
double price = Double.valueOf(data2.get(2))

data2.add("anotherval");
data2.add("anotherval");
data2.add("50.00");

sorted.add(data2);

按降序排列的LinkedHashSet的输出。

testval testval 100.00
anotherval anotherval 50.00

抱歉，如果这令人困惑，我不确定在哪里进行这样的排序。

4

3 回答 3

3

创建一个新类来表示您的复杂对象。当您可以在对象中执行此操作时，无需在列表中存储多个值。

public class ComplexObject {
    private String description1;
    private String description2;
    private Double value;

    public ComplexObject(String description1, String description2, Double value) {
        this.description1 = description1;
        this.description2 = description2;
        this.value = value;
    }

    public void setDescription1(String description1) {
        this.description1 = description1;
    }

    public String getDescription1() {
        return description1;
    }

    public void setDescription2(String description2) {
        this.description2 = description2;
    }

    public String getDescription2() {
        return description2;
    }

    public void setValue(Double value) {
        this.value = value;
    }

    public Double getValue() {
        return value;
    }
}

然后将元素添加到列表中并使用新的自定义比较器对其进行排序：

public static void main(String[] args) {

    List<ComplexObject> complexObjectList = new ArrayList<ComplexObject>();

    //add elements to the list
    complexObjectList.add(new ComplexObject("testval","testval",100.00d));
    complexObjectList.add(new ComplexObject("anotherval","anotherval",50.00d));

    //sort the list in descending order based on the value attribute of complexObject
    Collections.sort(complexObjectList, new Comparator<ComplexObject>() {
            public int compare(ComplexObject obj1, ComplexObject obj2) {
                return obj2.getValue().compareTo(obj1.getValue()); //compares 2 Double values, -1 if less , 0 if equal, 1 if greater
            }
        });

    //print objects from sorted list
    for(ComplexObject co : complexObjectList){
        System.out.println(co.getDescription1()+" "+co.getDescription2()+" "+co.getValue());
    }
}

输出：

测试验证测试验证 100.0
anotherval anotherval 50.0
于 2014-12-08T13:38:59.050 回答
3

首先，从Oracle 的 Java 参考中提取：

这个链表定义了迭代顺序，即元素插入集合的顺序

因此，您不能仅将数据插入到LinkedHashSet. 您可能会将 set 实现与SortedSet混淆。SortedSet允许您传递一个比较器，该比较器将确定数据结构中的元素顺序。

另一方面，我不知道您是否List<String>随意选择了您，但在我看来，将您的 3 个字符串聚合为一个类属性似乎是一个更明智的选择。关键是，如果你的元素总是 3 个元素，那么最后一个元素是 double 值：为什么你需要一个动态结构作为List?

编辑

在这里，您可以更好地实现您想要的：

public class Element
{
    public Element(String a, String b, double val) {
        this.a = a;
        this.b = b;
        this.val = val;
    }

    @Override
    public String toString() {
        return a + "\t" + b + "\t" + val;
    }

    public String a;
    public String b;
    public double val;
}

你可以使用这个类来存储你的元素。使用示例：

 SortedSet<Element> sorted = new TreeSet<>(new Comparator<Element>() {
        @Override
        public int compare(Element o1, Element o2) {
            return (new Double(o1.val)).compareTo(o2.val);
        }
    });

sorted.add(new Element("testval", "testval", 100.0));
sorted.add(new Element("anotherval", "anotherval", 50.0));
for(Element el: sorted)
{
    System.out.println(el);
}

Comparator请注意，比较器是作为实现 Java接口的匿名内部类的实例给出的。

于 2014-12-08T13:33:20.293 回答
3
  • 首先，你不应该使用 aLinkedHashSet而是 a TreeSet。LinkedHashSet将保留插入顺序而不进行排序。
  • 其次，您需要使用 a 来初始化您TreeSet，该 aComparator会根据您所需的任何值进行比较List，也就是说，如果您事先知道 a 的索引String将代表一个double值。否则我会推荐使用自定义对象而不是List.

如果您决定使用自定义对象，则不一定需要使用第二个参数来初始化您TreeSet的Comparator对象。

相反，您可以让您的自定义对象实现Comparable，并在那里实现一次性比较逻辑。

这完全取决于您是否只需要按特定顺序排序。

最后，自定义对象将要求您覆盖equals和hashCode.

于 2014-12-08T13:33:54.333 回答