Shuffling unordered collections in Java

There are two types of collections in Java. One is an ordered set and the other is an unordered set. An ordered collection stores elements in the order of insertion, i.e. it maintains the insertion order of elements. 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 built-in method 'Collections.shuffle()'.

Program to shuffle elements of Unordered Collection Set

SortedSet interface

The name of this interface contains the term "Sorted", which means that it contains all elements in ascending order. It extends the properties of the Set interface. In order to use the features of SortedSet, we will use a tree set class that implements the SortedSet interface.

grammar

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

Here, element_Type is a wrapper class, not a primitive data type.

Collections.shuffle()

is translated as:

Collections.shuffle()

This method is provided by the 'java.util' package as a shuffler. It accepts a collection as argument and randomly rearranges the elements.

grammar

Collections.shuffle( nameOfcollection );

How the code works

• We will create a Tree Set named 'treeSt' and use the built-in method 'add()' to store some elements of type String.

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

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

The Chinese translation of

Example

is:

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 for shuffling elements of an unordered set map

Tree

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 of TreeMap is as follows −

grammar

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

How the code works

• Create a TreeMap object named 'workers' and insert elements into it using the 'put()' method.

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

• Go ahead and use the method 'Collections.shuffle()' to shuffle the elements of the ArrayList.

• Finally, define a for-each loop to print the reshuffled elements. The 'getKey()' method will retrieve the key and 'getValue()' will get its corresponding value.

The Chinese translation of

Example

is:

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

in conclusion

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

The above is the detailed content of Shuffling unordered collections in Java. For more information, please follow other related articles on the PHP Chinese website!