You can use TreeMap

A Red-Black tree based NavigableMap implementation. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used.

Solution with Collections.sort

If you are forced to use this List, or if your program has a structure like

• Create a list
• Add some country names
• sort them once
• never change that list again

then Thilos answer is the best way to do it. Combine it with the advice from Tom Hawtin - tackline and you get

java.util.Collections.sort(listOfCountryNames, Collator.getInstance());

Solution with a TreeSet

If you have the choice, and if your application is likely to become more complex, you could modify your code to use a TreeSet instead. This kind of collection sorts your items as they are inserted. There is no need to call sort().

Collection<String> countryNames = 
    new TreeSet<String>(Collator.getInstance());
countryNames.add("UK");
countryNames.add("Germany");
countryNames.add("Australia");
// Voila... sorted.

Side note on why I prefer the TreeSet

It has some subtle but important advantages:

• It's just shorter. But only one line shorter.
• Never worry about is this list really sorted right now, because a TreeSet is always sorted, no matter what you do.
• You cannot have duplicate entries. Depending on your situation, this can be a pro or a con. If you need duplicates, stick to your list.
• An experienced programmer looks at TreeSet<String> countyNames and immediately knows: this is a sorted collection of strings without duplicates, and I can be sure that this is true at any moment. So much information in one short declaration.
• A real performance gain in some cases. If you use a list, and you insert values very often, and the list may be read between those insertions, then you have to sort the list after each insertion. The set does the same thing, but much faster.

Using the right collection for the right task is a key to writing short and bug-free code. It's not so demonstrative in this case, because you're only saving one line. But I've lost count of how often I see someone using a list when they want to make sure there are no duplicates, and then building that functionality themselves. Or even worse, using two lists when you really need one map.

Don't get me wrong: Using Collections.sort is not a bug or a mistake. But there are many cases where the TreeSet is much cleaner.

Add all your objects to the TreeSet, you will get a sorted Set. Below is a raw example.

HashSet myHashSet = new HashSet();
myHashSet.add(1);
myHashSet.add(23);
myHashSet.add(45);
myHashSet.add(12);

TreeSet myTreeSet = new TreeSet();
myTreeSet.addAll(myHashSet);
System.out.println(myTreeSet); // Prints [1, 12, 23, 45]

Update

You can also use TreeSet's constructor that takes a HashSet as a parameter.

HashSet myHashSet = new HashSet();
myHashSet.add(1);
myHashSet.add(23);
myHashSet.add(45);
myHashSet.add(12);

TreeSet myTreeSet = new TreeSet(myHashSet);
System.out.println(myTreeSet); // Prints [1, 12, 23, 45]

Thanks @mounika for the update.

Java 8

Set<Integer> myHashSet = new HashSet<>();
myHashSet.add(1);
myHashSet.add(23);
myHashSet.add(45);
myHashSet.add(12);

LinkedHashSet<Integer> ascendingSortedSet = myHashSet.stream()
    .sorted()
    .collect(Collectors.toCollection(LinkedHashSet::new)); // Prints [1, 12, 23, 45]

LinkedHashSet<Integer> descendingSortedSet = myHashSet.stream()
    .sorted(Comparator.reverseOrder())
    .collect(Collectors.toCollection(LinkedHashSet::new)); // Prints [45, 23, 12, 1]