# # Sets

## # 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<T> set = new HashSet<T>();

``````

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<T> sortedSet = new TreeSet<T>();

``````

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<T> linkedhashset = new LinkedHashSet<T>();

``````

## # 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.

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<Integer> set = new HashSet<Integer>(); // Creates an empty Set of Integers

Set<Integer> linkedHashSet = new LinkedHashSet<Integer>(); //Creates a empty Set of Integers, with predictable iteration order

``````

Elements can be added to a set using the `add()` method

``````

``````

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

``````Set<String> set = new HashSet<> ();

// Set Elements: ["Strawberry", "Banana", "Apple"]

``````

### #`LinkedHashSet` - Insertion Order

``````Set<String> set = new LinkedHashSet<> ();

// Set Elements: ["Banana", "Apple", "Strawberry"]

``````

### #`TreeSet` - By `compareTo()` or `Comparator`

``````Set<String> set = new TreeSet<> ();

// Set Elements: ["Apple", "Banana", "Strawberry"]

``````
``````Set<String> set = new TreeSet<> ((string1, string2) -> string2.compareTo(string1));

// Set Elements: ["Strawberry", "Banana", "Apple"]

``````

## # Declaring a HashSet with values

You can create a new class that inherits from HashSet:

``````Set<String> h = new HashSet<String>() {{
}};

``````

One line solution:

``````Set<String> h = new HashSet<String>(Arrays.asList("a", "b"));

``````

Using guava:

``````Sets.newHashSet("a", "b", "c")

``````

Using Streams:

``````Set<String> set3 = Stream.of("a", "b", "c").collect(toSet());

``````

## # Create a list from an existing Set

Using a new List

``````List<String> list = new ArrayList<String>(listOfElements);

``````

``````
Set<String> set = new HashSet<String>();

List<String> list = new ArrayList<String>();

``````

Using Java 8 Steam API

``````List<String> list = set.stream().collect(Collectors.toList());

``````

## # Eliminating duplicates using Set

Suppose you have a collection `elements`, and you want to create another collection containing the same elements but with all duplicates eliminated:

``````Collection<Type> noDuplicates = new HashSet<Type>(elements);

``````

Example:

``````List<String> names = new ArrayList<>(
Arrays.asList("John", "Marco", "Jenny", "Emily", "Jenny", "Emily", "John"));
Set<String> noDuplicates = new HashSet<>(names);
System.out.println("noDuplicates = " + noDuplicates);

``````

Output:

``````noDuplicates = [Marco, Emily, John, Jenny]

``````