Java 按相反顺序对集合排序

对于这个新手的问题，我深表歉意，但是以相反的顺序获取

集合

（比如

LinkedHashSet

）的正确方法是什么？对于

集合

s，有

集合。反向（集合c）

，但是对于带有有序元素的

集合

（如

LinkedHashSet

）如何执行呢？

请查看此项

---

如果使用树集，则可以通过调用degendingset获得相反的顺序。

集合通常不按顺序排列，因此为了保留排序，在将集合排序为列表后，需要使用集合的已知迭代顺序实现，例如LinkedHashSet

List list = new ArrayList(set);
Collections.sort(list, Collections.reverseOrder());
Set resultSet = new LinkedHashSet(list);

您也可以将TreeSet与比较器一起使用，但速度不如上面的ArrayList方法。

公共类LargestArray{
public class LargestArray {
public static void main(String[] args) {

    ArrayList<Integer> al = new ArrayList<>();
    Set<Integer> set = new TreeSet<>();
    set.add(10);
    set.add(20);
    set.add(7);
    set.add(4);
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(4);
    System.out.println("after Sorting");
    for(int i : set) {
        System.out.print("  " + i);
    }
    al.addAll(set);
    set.clear();
    Collections.reverse(al);
    System.out.println();
    System.out.println("After Reverse");
    for (int i : al) {
        System.out.print(" " + i);
    }

}

}

公共静态void main（字符串[]args）{
ArrayList al=新的ArrayList（）；
Set=新树集（）；
增加（10）；
增加（20）；
增加（7）；
增加（4）；
增加（1）；
增加（2）；
增加（3）；
增加（4）；
System.out.println（“排序后”）；
for（int i:set）{
系统输出打印（“+i”）；
}
al.addAll（套）；
set.clear（）；
收藏。反面（al）；
System.out.println（）；
System.out.println（“反转后”）；
for（int i:al）{
系统输出打印（“+i”）；
}
}
}

输出=排序后 1 2 3 4 7 10 20 反转后 201074321

---

我将用一个例子来解释你。注释添加在代码中间，以便更好地理解

public class ReverseLinkedHashSet {

    public static void main(String[] args) {

        // creating a LinkedHashSet object which is
        // of type String or any. Will take a example of String.
        HashSet<String> cars = new LinkedHashSet<String>();

        // adding car elements to LinkedHashSet object as below
        cars.add("Toyato");
        cars.add("Hundai");
        cars.add("Porshe");
        cars.add("BMW");

        // Iterating using enhanced for-loop to see the order.
        System.out.println("Insertion Order: Iterating LinkedHashSet\n");
        for(String car : cars) {
            System.out.println(car);

        // Output will be as below  
        //Toyato
        //Hundai
        //Porshe
        //BMW
        }

        // Now convert to ArrayList to rearrange to reverse
        // the linkedHashset
        List<String> listOfCars = new ArrayList<String>(cars);

        // to reverse LinkedHashSet contents
        Collections.reverse(listOfCars);

        // reverse order of LinkedHashSet contents
        // can be done as below
        System.out.println("\n\n\nReverse Order of LinkedHashSet\n");
        for(String car : listOfCars) {
            System.out.println(car);

        // Output will be as below  
        //BMW
        //Porshe
        //Hundai
        //Toyato    
        }
    }
}

公共类反向elinkdhasset{
公共静态void main（字符串[]args）{
//创建一个LinkedHashSet对象
//类型为String或any。将以String为例。
HashSet cars=newlinkedhashset（）；
//将汽车元素添加到LinkedHashSet对象，如下所示
添加（“Toyato”）；
添加（“混代”）；
汽车。添加（“保时捷”）；
加上（“宝马”）；
//使用增强的for循环进行迭代以查看顺序。
System.out.println（“插入顺序：迭代LinkedHashSet\n”）；
用于（串车：车）{
系统输出打印（car）；
//输出将如下所示
//托亚托
//浑岱
//波什
//宝马
}
//现在转换为ArrayList以重新排列为反转
//linkedHashset
列表cars=新阵列列表（cars）；
//要反转LinkedHashSet内容
收款。反向（现金清单）；
//LinkedHashSet内容的相反顺序
//可以按如下方式进行操作
System.out.println（“\n\n\n LinkedHashSet的相反顺序\n”）；
用于（字符串车：列表车）{
系统输出打印（car）；
//输出将如下所示
//宝马
//波什
//浑岱
//托亚托
}
}
}

---

此外，我建议没有充分理由不要使用

LinkedhashSet

。对于复杂的应用程序，它会降低性能。使用

HashSet

。

Java8，我使用下面的解决方案

Set<String> setTest = new HashSet<>();

setTest.add("1");
setTest.add("2");
setTest.add("3");

List<String> list = new ArrayList<>(setTest);
list.sort(Collections.reverseOrder());
Set<String> result = new LinkedHashSet<>(list);

for (String item: result) {
    System.out.println("---> " + item);
}

Result:

---> 3
---> 2
---> 1

Set setTest=new HashSet（）；
setTest.添加（“1”）；
setTest.添加（“2”）；
setTest.添加（“3”）；
列表列表=新的ArrayList（setTest）；
list.sort（Collections.reverseOrder（））；
设置结果=新建LinkedHashSet（列表）；
for（字符串项：结果）{
System.out.println（“-->”+项）；
}
结果:
---> 3
---> 2
---> 1

---

为我工作。

A

Set

没有订单。你能澄清一下吗？另外，

reverse

在Java中采用

列表

@SotiriosDelimanolis，

TreeSet

s将其项目按顺序排序。要以相反的顺序获取元素，可以使用

downingset（）

方法。对于

LinkedHashSet

，请参见以下答案：一个

LinkedHashSet

没有排序，它是

链接的

。如果您想以插入的相反顺序循环项目，请使用

迭代器

@boristesspider，这实际上取决于您所说的“有序”的含义

TreeSet

维护“排序”顺序，而

LinkedHashSet

维护插入顺序（因此有一个可预测的迭代顺序）。+1，为什么要进行向下投票？在我添加它们之后，

TreeSet

不会对它们重新排序（并混淆顺序）…不，这就是为什么需要比较器来维护顺序的原因。如果比较器没有正确实现，那么是的，您的顺序可能非常奇怪。OP使用的是

LinkedHashSet

-这保持了插入顺序。将项目放入

树集

显然会破坏这一点。除非你提供了一个显式的排序比较器-这在某种程度上破坏了对象。啊，这是在编辑中添加的。我很惊讶LinkedHashSet没有反向迭代器，因为文档中说实现是由一个双链接列表支持的。这确实是在我添加帖子一两分钟后添加的。对此很抱歉。对于较大的数据集，这不是效率低下（内存方面的）吗（因为您将在内存中两次存储相同的数据）？我的输入是

集合

，而不是

列表

。Java Collections API似乎不允许常量空间排序或任意集合。您可能需要将自己限制在SortedSet API中，以便从我所能告诉您的情况中了解这一点。