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 SortingVersion ≥ 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());