Shuffling Elements of Unordered Collections in Java

There are two types of collections in Java. One is ordered and the other one is unordered collection. The ordered collections store their elements in the order in which they are inserted i.e. it maintains the insertion order of elements. Whereas, the unordered collections such as Map and Set do not maintain any order.

In this article, we will create an unordered collection and try to shuffle its elements using the inbuilt method ‘Collections.shuffle()’.

Program to shuffle elements of Unordered Collection Set

SortedSet Interface

This interface has the term ‘Sorted’ in its name which signifies that it contains all the elements in ascending order. It extends the properties of the Set interface. To use the features of SortedSet, we will use tree set class that implements SortedSet interface.

Syntax

SortedSet< element_Type > collection_name = new TreeSet<>();

Here, element_Type is the wrapper class not primitive datatypes.

Collections.shuffle()

This method is provided by ‘java.util’ package and serves as a shuffler. It takes a collection as an argument and then rearranges the elements randomly.

Syntax

Collections.shuffle( nameOfcollection );

Working of Code

• We will create a Tree Set named ‘treeSt’ and store a few elements of type String using an inbuilt method ‘add()’.

• Now, create a new ArrayList and copy all the elements of the previous Tree Set.

• In the end, use the method ‘Collections.shuffle()’ to shuffle the elements of ArrayList and then print them.

Example

import java.util.*;
public class Srtset {
   public static void main(String args[]) {
      // Creating a tree set
      SortedSet<String> treeSt = new TreeSet<>();
      // Adding elements in the tree set
      treeSt.add("Tutorix");
      treeSt.add("Simply");
      treeSt.add("Easy");
      treeSt.add("Learning");
      treeSt.add("Tutorials");
      treeSt.add("Point");
      // print elements before shuffling 
      System.out.println("Elements of the given set without performing shuffling: ");
      System.out.println(treeSt);
      // storing the elements of tree set in array list 
      List<String> arayList = new ArrayList<>(treeSt);
      // performing shuffle operation on list
      Collections.shuffle(arayList);
      // display the shuffled elements
      System.out.println("Shuffled elements of the given set: ");
      System.out.println(arayList);
   }
}

Output

Elements of the given set without performing shuffling: 
[Easy, Learning, Point, Simply, Tutorials, Tutorix]
Shuffled elements of the given set: 
[Easy, Simply, Learning, Tutorix, Tutorials, Point]

Program to shuffle elements of Unordered Collection Map

Tree Map

It is a class that is used to implement NavigableMap Interface. It stores the elements of the map in a tree structure. To sort the LinkedHashMap elements we need to use this class. The most obvious reason for this is that it provides an efficient alternative to store the key-value pairs in sorted order.

The general syntax for TreeMap is as follows −

Syntax

TreeMap< TypeOfKey, TypeOfValue > nameOfMap = new TreeMap<>();

Working of Code

• Create an object of TreeMap named ‘workers’ and use the ‘put()’ method that will insert elements to it.

• Now, define a new ArrayList and copy all the elements of ‘workers’ using ‘entrySet()’ method.

• Moving ahead, use the method ‘Collections.shuffle()’ to shuffle the elements of ArrayList.

• In the end, define a for-each loop to print the newly shuffled elements. The ‘getKey()’ method will retrieve the key and ‘getValue()’ will fetch its corresponding value.

Example

import java.util.*;
public class Suffle {
   public static void main(String args[]) {
      TreeMap<String, Integer> workers = new TreeMap<>();
      // Adding elements in the workers map
      workers.put("Vaibhav", 4000);
      workers.put("Ansh", 3000);
      workers.put("Vivek", 1500);
      workers.put("Aman", 2000);
      workers.put("Tapas", 2500);
      // printing details workers map without shuffle
      System.out.println("Elements of the map: ");
      for (String unKey : workers.keySet()) {
         System.out.println("Name: " + unKey + ", Salary: " + workers.get(unKey));
      }
      // create new ArrayList
      List<Map.Entry<String, Integer>> arayList = new ArrayList<>(workers.entrySet());
      Collections.shuffle(arayList);
      // printing details after shuffling
      System.out.println("Elements of the newly shuffled map: ");
      for (Map.Entry<String, Integer> print : arayList) {
         System.out.println("Name: " + print.getKey() + ", Salary: " + print.getValue());
      }
   }
}

Output

Elements of the map: 
Name: Aman, Salary: 2000
Name: Ansh, Salary: 3000
Name: Tapas, Salary: 2500
Name: Vaibhav, Salary: 4000
Name: Vivek, Salary: 1500
Elements of the newly shuffled map: 
Name: Vaibhav, Salary: 4000
Name: Aman, Salary: 2000
Name: Vivek, Salary: 1500
Name: Ansh, Salary: 3000
Name: Tapas, Salary: 2500

Conclusion

In this article, we have learned how we can shuffle the elements of an unordered collection with the help of examples. We also discovered two of the unordered collections named Map and Set.