Is Set sorted in some manner by default?

Question

I have this set with elements added in the given order.

        Set<String> nations = new HashSet<String>();
        nations.add("Australia");
        nations.add("Japan");
        nations.add("Taiwan");
        nations.add("Cyprus");
        nations.add("Cuba");
        nations.add("India");

When I print the record -

for (String s : nations) {
    System.out.print(s + " ");
}

It always gives this output in the order

Cuba Cyprus Japan Taiwan Australia India 

As far as I know a Set is not sorted by default, but why do I get the same result in a particular sorted manner?

---

Update : Here is the actual question -

public static Function<String,String> swap = s -> {
    if(s.equals("Australia"))
        return "New Zealand";
    else
        return s;
    };

Set<String> islandNations = Set.of("Australia", "Japan", "Taiwan", "Cyprus", "Cuba");
islandNations = islandNations.stream()
    .map(swap)
    .map(n -> n.substring(0, 1))
    .collect(Collectors.toSet());
for(String s : islandNations){
    System.out.print(s);
}

and answers one of these

• CTJN
• TJNC
• TCNJ

Answer 1

HashSet's documentation says:

It makes no guarantees as to the iteration order of the set.

No guarantees means no guarantees. For example, it could be sorted order, reverse sorted order, random order, or sorted order except on Tuesdays when it's random.

(In practice, the iteration order is usually always the same for the same Java version, or at least for the same run of the JVM, and that order is produced by a deliberately convoluted algorithm based on the hash codes of the elements. However, if you depend on that behavior, it will usually change at the worst possible time.)

Answer 2

HashSet does not preserve the order of insertion of elements, as the order is maintained based on the hashing mechanism like Map because the add() method internally inserts the element as a key in a Map.

HashSet

//add method implementation for HashSet
 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

here, map is a private transient HashMap<E,Object> map;
      As the map is HashMap here, so no sorting will be done.

TreeSet

//add method implementation for TreeSet
 public boolean add(E e) {
        return m.put(e, PRESENT)==null;
    }

here, map is a private transient NavigableMap<E,Object> m;
      As the map is NavigableMap here, so sorting will be done.

Answer 3

The HashSet uses the hash value of each element for storage.

The important points about Java HashSet class are:

• HashSet stores the elements by using a mechanism called hashing.
• HashSet contains unique elements only.
• HashSet allows null value.
• HashSet class is non-synchronized.
• HashSet doesn't maintain the insertion order. Here, elements are inserted on the basis of their hashcode.
• HashSet is the best approach for search operations.
• The initial default capacity of HashSet is 16, and the load factor is 0.75.

if you need to store (and display) in the order you can use the SortedSet interface, like this:

SortedSet<String> orderedList = new TreeSet<String>(); 
    orderedList.add("C"); 
    orderedList.add("D"); 
    orderedList.add("E"); 
    orderedList.add("A"); 
    orderedList.add("B"); 
    orderedList.add("Z"); 

    for (String value : orderedList) 
        System.out.print(value + ", "); 

Output: A, B, C, D, E, Z,

Remembering: SortedSet uses the Comparable interface and the compareTo() method to sort the String values. If you have a customized class you should implement this interface/method to use in this approach.

Or, you can define the comparator that must be used:

SortedSet<Person> persons = new TreeSet<>Comparator.comparing(Person::getName));