The Set interface contains only methods inherited from Collection and adds the restriction that duplicate elements are prohibited.
Initialization
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.
Set have its implementation in various classes like HashSet, TreeSet, LinkedHashSet.
For example:
HashSet:
Set set = new HashSet();
Here T can be String, Integer or any other object. HashSet allows for quick lookup of O(1) but does not sort the data added to it and loses the insertion order of items.
TreeSet:
It stores data in a sorted manner sacrificing some speed for basic operations which take O(lg(n)). It does not maintain the insertion order of items.
TreeSet sortedSet = new TreeSet();
LinkedHashSet:
It is a linked list implementation of HashSet Once can iterate over the items in the order they were added. Sorting is not provided for its contents. O(1) basic operations are provided, however there is higher cost than HashSet in maintaining the backing linked list.
LinkedHashSet linkedhashset = new LinkedHashSet();
Basics of Set
What is a Set?
A set is a data structure which contains a set of elements with an important property that no two elements in the set are equal.
Related Article: List vs Set in Java
Types of Set:
- HashSet: A set backed by a hash table (actually a HashMap instance)
- Linked HashSet: A Set backed by Hash table and linked list, with predictable iteration order
- TreeSet: A NavigableSet implementation based on a TreeMap.
Creating a set
Set set = new HashSet(); // Creates an empty Set of Integers Set linkedHashSet = new LinkedHashSet(); //Creates a empty Set of Integers, with predictable iteration order
Adding elements to a Set
Elements can be added to a set using the add() method
set.add(12); // - Adds element 12 to the set
set.add(13); // - Adds element 13 to the set
Our set after executing this method:
set = [12,13]
Delete all the elements of a Set
set.clear(); //Removes all objects from the collection.
After this set will be:
set = []
Check whether an element is part of the Set
Existence of an element in the set can be checked using the contains() method
set.contains(0); //Returns true if a specified object is an element within the set.
Output: False
Check whether a Set is empty
isEmpty() method can be used to check whether a Set is empty.
set.isEmpty(); //Returns true if the set has no elements
Output: True
Remove an element from the Set
set.remove(0); // Removes first occurrence of a specified object from the collection
Check the Size of the Set
set.size(); //Returns the number of elements in the collection
Output: 0
Types and Usage of Sets
Generally, sets are a type of collection which stores unique values. Uniqueness is determined by the equals() and hashCode() methods.
Sorting is determined by the type of set.
HashSet - Random Sorting
Version ≥ Java SE 7
Set set = new HashSet<> ();
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");
// Set Elements: ["Strawberry", "Banana", "Apple"]
LinkedHashSet – Insertion Order
Version ≥ Java SE 7
Set set = new LinkedHashSet<> ();
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");
// Set Elements: ["Banana", "Apple", "Strawberry"]
TreeSet – By compareTo() or Comparator
Version ≥ Java SE 7
Set set = new TreeSet<> ();
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");
// Set Elements: ["Apple", "Banana", "Strawberry"]
Version ≥ Java SE 7
Set set = new TreeSet<> ((string1, string2) -> string2.compareTo(string1));
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");
// Set Elements: ["Strawberry", "Banana", "Apple"]
Create a list from an existing Set
Using a new List
List list = new ArrayList(listOfElements);
Using List.addAll() method
Set set = new HashSet();
set.add("foo");
set.add("boo");
List list = new ArrayList();
list.addAll(set);
Using Java 8 Steam API
List list = set.stream().collect(Collectors.toList());
Eliminating duplicates using Set
Suppose you have a collection element, and you want to create another collection containing the same elements but with all duplicates eliminated:
Collection noDuplicates = new HashSet(elements);
Example:
List<String> names = new ArrayList<>(
Arrays.asList("John", "Marco", "Jenny", "Emily", "Jenny", "Emily", "John"));
Set noDuplicates = new HashSet<>(names);
System.out.println("noDuplicates = " + noDuplicates);
Output:
noDuplicates = [Marco, Emily, John, Jenny]
Declaring a HashSet with values
You can create a new class that inherits from HashSet:
Set h = new HashSet<String>() {{
add(“a”);
add(“b”);
}};
One line solution:
Set h = new HashSet(Arrays.asList("a", "b"));
Using guava:
Sets.newHashSet("a", "b", "c")
Using Streams:
Set set3 = Stream.of("a", "b", "c").collect(toSet());