The Set Interface in Java

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:

  1. HashSet: A set backed by a hash table (actually a HashMap instance)
  2. Linked HashSet: A Set backed by Hash table and linked list, with predictable iteration order
  3. 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());

LEAVE A REPLY

Please enter your comment!
Please enter your name here