Sort a Set in reverse order

Question

Apologies for the newbie question, but what's the proper way to get a Set (say LinkedHashSet) in reverse order? For Collections there's Collections.reverse(Collection c), but how does one do it for a Set with ordered elements (like a LinkedHashSet)?

Answer 1

Sets are not ordered in general, so to preserve the sorting, after sorting the set as a list, you would need to use a known iteration order implementation of Set, such as LinkedHashSet

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

You could also use TreeSet with a comparator, but that is not as fast as the ArrayList method above.

Answer 2

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);
    }

}

}

output = after Sorting 1 2 3 4 7 10 20 After Reverse 20 10 7 4 3 2 1

Answer 3

Check this out

http://docs.oracle.com/javase/7/docs/api/java/util/TreeSet.html#descendingSet()

If you use a TreeSet you can get reverse order by calling descendingSet.

Answer 4

I will explain you with an example. Comments are added in mid of the code for better understanding.

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    
        }
    }
}

Also, I suggest not to use LinkedhashSet without a strong reason. For a complex application, it will reduce the performance. Use HashSet instead.

Answer 5

Java 8, I using solution below,

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

Work for me.

Answer 6

Java 21 is introducing the SequencedSet interface for reversible sets which have a well defined insertion order. LinkedHashSet implements the interface and SortedSet extends it. For such a set, the reversed() method will return a reversed view of it.

SequencedSet<String> set = new LinkedHashSet<>(List.of("A", "B", "C"));
SequencedSet<String> reversedSet = set.reversed();
System.out.println(reversedSet); // [C, B, A]