Kosta Lazarevski
By Kosta Lazarevski

Set interface in Java

Set interface in Java

Set Interface

The Set Interface java.util.Set represents an unordered list of elements(objects). Set Interface can store only unique values, that means that you can not have duplicates in Set. Set interface is implemented by the classes HashSet, LinkedHashSet, TreeSet(this class implements the SortedSet Interface). Set has many methods to add, remove and manipulate data.

HashSet

HashSet class stores elements in a hash table, and it is best performing implementation of the Set. It does not guarantee the order in which elements are inserted. HashSet allows null values but can not contain duplicate values. Internally uses a HashMap to store the elements.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


import java.util.HashSet;

import java.util.Set;



public class HashSetExample{

  public static void main(String [] args){

     

     //Creating a HashSet

     Set <String> names = new HashSet<String>();



     //Adding new elements to the HashSet

     names.add(Mike);  

     names.add(Bob);

     names.add(Maria);

     names.add(Karen);

     names.add(Mike);



     System.out.println(names);



     //Removing an element of the HashSet 

     boolean isRemoved = names.remove(Bob);

     System.out.println(names);



     //Iterating over a HashSet

     for(String name: names){

      System.out.println(name);

      }

  }

} 



Output:

[Maria, Karen, Mike, Bob]

[Karen, Maria, Mike]

[Mike, Karen, Maria]

LinkedHashSet

LinkedHashSet class is an ordered version of HashSet. It is the implementation of LinkedList in the Set Interface. Internally it uses a hash table with linked lists running through it to store the elements. It keeps the insertion order.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


import java.util.LinkedHashSet;

import java.util.Set;



public class LinkedHashSetExample{

  public static void main(String [] args){

     

     //Creating a HashSet

     Set <String> names = new LinkedHashSet<String>();



     //Adding new elements to the HashSet

     names.add(Mike);  

     names.add(Bob);

     names.add(Maria);

     names.add(Karen);

     names.add(Mike);



     System.out.println(names);



     //Removing an element of the HashSet 

     boolean isRemoved = names.remove(Bob);

     System.out.println(names);



     //Iterating over a HashSet

     for(String name: names){

      System.out.println(name);

      }

  }

} 



Output:

[Mike, Bob, Maria, Karen]

[Mike, Maria, Karen]

[Mike, Maria, Karen]

TreeSet

TreeSet class implements the Navigable Interface which implements the

SortedSet Interface. SortedSet gives functionalities to keep the elements sorted and Navigable gives functionalities to navigate through the TreeSet. Internally it uses a TreeMap to store the elements.TreeSet stores the elements by their natural order(alphabetical or numerical) or based on a custom Comparator that is supplied at the time a TreeSet is created.. You can not have duplicates and null values in TreeSet. It is very useful for storing large amounts of sorted data because it accesses and can retrieve data very fast.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


import java.util.SortedSet;

import java.util.TreeSet;



public class TreeSetExample{



  public static void main(String [] args){



     //Creating a TreeSet

     SortedSet<String> fruits = new TreeSet<String>();



     //Adding elements to a TreeSet

     fruits.add(Peach);

     fruits.add(Apple);

     fruits.add(Pear);

     fruits.add(Banana);



     System.out.println(fruits);

     

     //This will add element because it is lower case

     fruits.add(apple);

     System.out.println(fruits);

     

   }



}



Output:

[Apple, Banana, Peach, Pear]

[Apple, Banana, Peach, Pear, apple]

TreeSet with a custom comparator:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.util.SortedSet;

import java.util.TreeSet;



public class TreeSetExample{



  public static void main(String [] args){



  //Creating a TreeSet using a Comparator

   SortedSet<String> fruits = new TreeSet<String>(String.CASE_INSESITIVE_ORDER);



     //Adding elements to a TreeSet

     fruits.add(Peach);

     fruits.add(Apple);

     fruits.add(Pear);

     fruits.add(Banana); 



     //Lower case will be duplicates now

     fruits.add(apple);



     System.out.println(fruits); 

  }

}

Output:

[Apple, Banana, Peach, Pear]