Java Tutorial/Collections/HashSet

Adding Another Collection with the addAll() method: public boolean addAll(Collection c)

Each element in the collection passed in will be added to the set via the equivalent of calling the add() method on each element.

If the underlying set changes, true is returned.

If no elements are added, false is returned.

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   elements = new String[] { "E", "F" };
   set.addAll(Arrays.asList(elements));
   System.out.println(set);
 }

}</source>

[D, A, F, C, B, E]

Adding Single Elements: the add() method

To modify an element in a set, you should remove it, modify it, and then re-add it.

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   set.add("Z");
   System.out.println(set);
 }

}</source>

[Z, D, A, C, B, E]

An easy way to initialize a set without manually adding each element

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   System.out.println(set);
 }

}</source>

[D, A, C, B, E]

Check if a particular element exists in HashSet

   <source lang="java">

import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<Integer> hSet = new HashSet<Integer>();
   hSet.add(new Integer("1"));
   hSet.add(new Integer("2"));
   hSet.add(new Integer("3"));
   System.out.println(hSet.contains(new Integer("3")));
 }

}</source>

Checking for Existence: the contains() method reports if a specific element is within the set

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   System.out.println(set.contains("A"));
 }

}</source>

true

Checking for no elements in the set: use the isEmpty() method instead

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   System.out.println(set.isEmpty());
 }

}</source>

false

Convert array to Set

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; public class Main {

 public static void main(String[] args) {
   Integer[] numbers = { 7, 7, 8, 9, 10, 8, 8, 9, 6, 5, 4 };
   List<Integer> list = Arrays.asList(numbers);
   Set<Integer> set = new HashSet<Integer>(list);
   for (Iterator iterator = set.iterator(); iterator.hasNext();) {
     Object o = iterator.next();
     System.out.print(o + ", ");
   }
 }

}</source>

Converting elements in a set to Array: public Object[] toArray()

The first toArray() method will return an Object array containing all the elements in the collection.

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   Object[] arrObj = set.toArray();
   for (int i = 0; i < arrObj.length; i++) {
     System.out.println(arrObj[i]);
   }
   System.out.println(set); 
 }

}</source>

D
A
C
B
E
[D, A, C, B, E]

Copy all elements of HashSet to an Object Array

   <source lang="java">

import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<Integer> hSet = new HashSet<Integer>();
   hSet.add(new Integer("1"));
   hSet.add(new Integer("2"));
   hSet.add(new Integer("3"));
   Object[] objArray = hSet.toArray();
   for (Object obj : objArray)
     System.out.println(obj);
 }

}</source>

Copying and Cloning Sets: public Object clone()

Calling the clone() method of a HashSet creates a shallow copy of that HashSet.

(the elements of the set aren"t duplicated. Both sets will refer to the same elements.

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   Set set2 = ((Set) ((HashSet) set).clone());
   System.out.println(set2);
 }

}</source>

[D, A, C, B, E]

Create unique lists of items?

   <source lang="java">

import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String args[]) {
   String[] name1 = { "Amy", "Jose", "Jeremy", "Alice", "Patrick" };
   String[] name2 = { "Alan", "Amy", "Jeremy", "Helen", "Alexi" };
   String[] name3 = { "Adel", "Aaron", "Amy", "James", "Alice" };
   Set<String> letter = new HashSet<String>();
   for (int i = 0; i < name1.length; i++)
     letter.add(name1[i]);
   for (int j = 0; j < name2.length; j++)
     letter.add(name2[j]);
   for (int k = 0; k < name3.length; k++)
     letter.add(name3[k]);
   System.out.println(letter.size() + " letters must be sent to: " + letter);
 }

}</source>

11 letters must be sent to: [Patrick, Amy, Jeremy, Adel, Alexi, Aaron, Jose, Alice, James, Helen, Alan]

Creating a HashSet

The HashSet class provides four constructors broken into two sets. The first three constructors create empty sets of varying sizes:

   <source lang="java">

public HashSet() public HashSet(int initialCapacity) public HashSet(int initialCapacity, int loadFactor)</source>

If the original collection had duplicates, only one of the duplicates will be in the final created set.

Fetching Elements: to work with all of the elements of the set

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   Iterator iter = set.iterator();
   while (iter.hasNext()) {
     System.out.println(iter.next());
   }
 }

}</source>

D
A
C
B
E

Find maximum element of HashSet

   <source lang="java">

import java.util.Collections; import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<Long> hashSet = new HashSet<Long>();
   hashSet.add(new Long("1111111111"));
   hashSet.add(new Long("2222222222"));
   hashSet.add(new Long("3333333333"));
   hashSet.add(new Long("4444444444"));
   hashSet.add(new Long("5555555555"));
   Object obj = Collections.max(hashSet);
   System.out.println(obj);
 }

}</source>

Find Minimum element of HashSet

   <source lang="java">

import java.util.Collections; import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<Long> hashSet = new HashSet<Long>();
   hashSet.add(new Long("9"));
   hashSet.add(new Long("4"));
   hashSet.add(new Long("2"));
   hashSet.add(new Long("2"));
   hashSet.add(new Long("3"));
   Object obj = Collections.min(hashSet);
   System.out.println("Minimum Element of HashSet is : " + obj);
 }

}</source>

Get Enumeration over HashSet

   <source lang="java">

import java.util.Collections; import java.util.Enumeration; import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<String> hashSet = new HashSet<String>();
   hashSet.add("A");
   hashSet.add("B");
   hashSet.add("D");
   hashSet.add("E");
   hashSet.add("F");
   Enumeration e = Collections.enumeration(hashSet);
   while (e.hasMoreElements())
     System.out.println(e.nextElement());
 }

}</source>

Get Size of HashSet

   <source lang="java">

import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<Integer> hSet = new HashSet<Integer>();
   System.out.println("Size of HashSet : " + hSet.size());
   hSet.add(new Integer("1"));
   hSet.add(new Integer("2"));
   hSet.add(new Integer("3"));
   System.out.println(hSet.size());
   hSet.remove(new Integer("1"));
   System.out.println(hSet.size());
 }

} /* Size of HashSet : 0 3 2

• /</source>

Get Synchronized Set from HashSet

   <source lang="java">

import java.util.Collections; import java.util.HashSet; import java.util.Set; public class Main {

 public static void main(String[] args) {
   HashSet hashSet = new HashSet();
   Set set = Collections.synchronizedSet(hashSet);
 }

}</source>

HashSet implements the empty Serializable interface

If, and only if, all of the elements of a HashSet are Serializable, HashSet can be saved to an ObjectOutputStream and later read it in to an ObjectInputStream.

   <source lang="java">

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) throws Exception{
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   
   FileOutputStream fos = new FileOutputStream("set.ser");
   ObjectOutputStream oos = new ObjectOutputStream(fos);
   oos.writeObject(set);
   oos.close();
   
   FileInputStream fis = new FileInputStream("set.ser");
   ObjectInputStream ois = new ObjectInputStream(fis);
   Set anotherSet = (Set) ois.readObject();
   ois.close();
   System.out.println(anotherSet);
 }

}</source>

[D, A, C, B, E]

Integer value set

   <source lang="java">

import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<Integer> hSet = new HashSet<Integer>();
   hSet.add(new Integer("1"));
   hSet.add(new Integer("2"));
   hSet.add(new Integer("3"));
   System.out.println("HashSet contains.." + hSet);
 }

} //HashSet contains..[1, 2, 3]</source>

Iterate through elements of HashSet

   <source lang="java">

import java.util.HashSet; import java.util.Iterator; public class Main {

 public static void main(String[] args) {
   HashSet<Integer> hSet = new HashSet<Integer>();
   hSet.add(new Integer("1"));
   hSet.add(new Integer("2"));
   hSet.add(new Integer("3"));
   Iterator itr = hSet.iterator();
   while (itr.hasNext())
     System.out.println(itr.next());
 }

}</source>

Listing the Elements of a Collection(iterate over the elements of set or list)

   <source lang="java">

import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class Main {

 public static void main(String[] argv) throws Exception {
   Set collection = new HashSet();
   // For a set or list
   for (Iterator it = collection.iterator(); it.hasNext();) {
     Object element = it.next();
   }
 }

}</source>

Making a Collection Read-Only

   <source lang="java">

import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; public class Main {

 public static void main(String[] argv) throws Exception {
   List stuff = Arrays.asList(new String[] { "a", "b" });
   List list = new ArrayList(stuff);
   list = Collections.unmodifiableList(list);
   try {
     list.set(0, "new value");
   } catch (UnsupportedOperationException e) {
     
   }
   Set set = new HashSet(stuff);
   set = Collections.unmodifiableSet(set);
   Map map = new HashMap();
   map = Collections.unmodifiableMap(map);
 }

}</source>

public Object[] toArray(Object[] a)

When all elements of a collection are of the same type, it is easier for you to work with an array of that specific type.

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   String[] strObj = new String[set.size()];
   strObj = (String[]) set.toArray(strObj);
   for (int i = 0; i < strObj.length; i++) {
     System.out.println(strObj[i]);
   }
   System.out.println(set);
 }

}</source>

D
A
C
B
E
[D, A, C, B, E]

Remove all elements from HashSet

   <source lang="java">

import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<Integer> hSet = new HashSet<Integer>();
   hSet.add(new Integer("1"));
   hSet.add(new Integer("2"));
   hSet.add(new Integer("3"));
   System.out.println(hSet);
   hSet.clear();
   System.out.println(hSet);
   System.out.println(hSet.isEmpty());
 }

} /* [1, 2, 3] [] true

• /</source>

Remove specified element from HashSet

   <source lang="java">

import java.util.HashSet; public class Main {

 public static void main(String[] args) {
   HashSet<Integer> hSet = new HashSet<Integer>();
   hSet.add(new Integer("1"));
   hSet.add(new Integer("2"));
   hSet.add(new Integer("3"));
   System.out.println(hSet);
   boolean blnRemoved = hSet.remove(new Integer("2"));
   System.out.println(blnRemoved);
   System.out.println(hSet);
 }

} /* [1, 2, 3] true [1, 3]

• /</source>

Removing All Elements: public void clear()

You can still get an UnsupportedOperationException thrown when working with a read-only set.

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   elements = new String[] { "E", "F" };
   set.addAll(Arrays.asList(elements));
   System.out.println(set);
   set.clear();
   System.out.println(set);
 }

}</source>

[D, A, F, C, B, E]
 []

Removing Single Elements: public boolean remove(Object element)

Determining via the equals() method of the element.

If the element is found, the element is removed and true is returned.

If not found, false is returned.

If removal is not supported, you"ll get an UnsupportedOperationException thrown.

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   set.remove("A");
   System.out.println(set);
 }

}</source>

[D, C, B, E]

Set and HashSet

1. A Set represents a mathematical set.
2. It is a Collection that, unlike List, does not allow duplicates.
3. There must not be two elements of a Set, say e1 and e2, such that e1.equals(e2).
4. The add method of Set returns false if you try to add a duplicate element.

   <source lang="java">

import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   Set set = new HashSet();
   set.add("Hello");
   if (set.add("Hello")) {
     System.out.println("addition successful");
   } else {
     System.out.println("addition failed");
   }
 }

}</source>

addition failed

1. HashSet allows at most one null element.
2. HashSet is faster than other implementations of Set, TreeSet and LinkedHashSet.

the containsAll() method checks if a set contains another whole collection

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   elements = new String[] { "A", "B", "C" };
   Set set2 = new HashSet(Arrays.asList(elements));
   System.out.println(set.containsAll(set2));
 }

}</source>

true

The HashSet class defines equality through its equals() method: public boolean equals(Object o)

A HashSet is equal to another object if the other object implements the Set interface, has the same size(), and contains all the same elements.

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   elements = new String[] { "A", "B", "C", "D" };
   Set set2 = new HashSet(Arrays.asList(elements));
   System.out.println(set.equals(set2));
 }

}</source>

false

To find out how many elements are in a set, use the size() method

   <source lang="java">

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class MainClass {

 public static void main(String[] a) {
   String elements[] = { "A", "B", "C", "D", "E" };
   Set set = new HashSet(Arrays.asList(elements));
   System.out.println(set.size());
 }

}</source>

5