How to Reverse order of values in Set<String>

If you want the keys of the Map to be ordered, you must use a different Map implementation, since the keys of a HashMap are not ordered.

You can use a TreeMap. You can pass to its constructor a Comparator that would determine the ordering of the keys. That would determine the order of the keys in the Set returned by keySet().

For example, if you want your movies to be sorted according to reversed lexicographical order:

Map<String,Movie> moviesByName = new TreeMap<>((s1,s2)->s2.compareTo (s1));

or, as lexicore suggested:

Map<String,Movie> moviesByName = new TreeMap<>(Comparator.<String>naturalOrder().reversed());

If you are using Java8 you can try:

List<String> sorted = movieList.keySet().stream()
                .sorted(Collections.reverseOrder())
                .collect(Collectors.toList());

Or even better if you want only the output String:

String output = movieList.keySet().stream()
                .sorted(Collections.reverseOrder())
                .collect(Collectors.joining("\n"));

But if the intent is to just reverse the map.keySet as Andreas suggested ... then

ArrayList<String> list = new ArrayList<>(movieList.keySet());
Collections.reverse(list);
//list is now in reverse order of the keySet

JEP 431: Sequenced Collections (release 9/19/23) in Java 21 has a reversed() method to SortedSet. This reversed view of the SortedSet can iterate in descending order.

SortedSet<String> movies =  movieList.keySet();
for(String movie : movies.reversed()) {
    output += movie + "\n";
}

That being said you may want to use a StringBuilder() for your output variable.

A key quality of a Set is that it not sorted. So you need to use another data structure to achieve this goal. The simplest solution may be a List, but then you loose the quality of a Set to not contain entires that are equal (entry.equals(otherentry) == true)

If you want to retrieve entries in the order of filling (or reverse) and still want to retain the Set quality, you may use a LinkedHashSet

The solution of Eran is also possible, but there you need to create a comparator that results in the order of addition to the TreeMap.

After getting values stored in a Set, Add all values of Set into a List then apply reverse function of list. Below is an example

import java.util.*;
class Test
{
public static void main(String args[])
{
Set h=new LinkedHashSet();
List h2 = new LinkedList();
h.add("Lovely");
h.add("Professional");
h.add("University");
h2.addAll(h);   
System.out.println(h);
Collections.reverse(h2);
System.out.println(h2);
}
}