JAVA INTERVIEW QUESTIONS & ANSWERS
HashSet
Java Hash
Set is a useful class implementation of Java
Collection framework.
HashSet implements
Serializable, Cloneable, Iterable<E>, Collection<E> and
Set<E> interfaces and
extends AbstractSet class directly.
Java Hash Set does not contains duplicate values, allows
null values and does not guarantee if the order of elements will remain same
over the time.
Hash Set in Java provides a huge set of implementations, some of the basic and commonly used operations are listed below with proper example.
Hash Set in Java provides a huge set of implementations, some of the basic and commonly used operations are listed below with proper example.
How to create a Java Hash Set
A Java HashSet object can be
obtained as shown below, gnerics specification is optional but it is always a
good practice to tell JVM about the content that is going to be stored in
HashSet. Use of generics eleminates the need of explicit type casting.
- // creating a new hash set with String elements
- HashSet<String> hashSet = new HashSet<String>(); // using generics --String in this case
How to add Elements to a Java Hash Set - add() & addAll()
Java HashSet provides two methods to
add elements to it, add() adds a single object at a time while addAll() can be
used to add all elements from a specified collection to the HashSet.
- // adding elements to hash set
- hashSet.add("element1"); // add elements
- // adding a collection using addAll()
- HashSet<String> hashSet2 = new HashSet<String>(); //new Hash Set to add
- hashSet2.add("newHashSet1"); // adding elements to new Hash Set
- hashSet2.add("newHashSet2");
- System.out.println(hashSet2); // show elements in new hash set
- hashSet.addAll(hashSet2); // adding new hash set
- System.out.println(hashSet); // elements after adding collection using addAll
How to remove Elements from Java Hash Set - remove() &
removeAll()
Hash Set in java provides two
methods to remove elements from HashSet, remove() remmoves one element while
removeAll() removes all elements from HashSet that are present in specified
collection.
- // removing elements from hash set
- hashSet.remove("element1"); // remove elements
- System.out.println(hashSet);
- hashSet.removeAll(hashSet2); //removes all elements present in specified collection
How to make Java Hash Set Empty - clear()
Java Hash Set provides clear()
method to remove all elements from a HashSet, it makes HashSet an empty
collection.
- // removing all elements from hash set
- hashSet.clear();
- System.out.println(hashSet); // return an empty hash set
How to clone a Java HashSet
Creates a shallow copy of HashSet
instance but elements does not coloned themeselves. While comparing a HashSet
and its clone using .equals(), it always returns a 'true'.
- //cloning hash set
- HashSet cloneHashSet = (HashSet) hashSet.clone(); // returns a shallow copy of hash set
- System.out.println(cloneHashSet);
- System.out.println(hashSet.equals(cloneHashSet)); // returns a true
How to compare Java HashSet using .equals()
It returns true if the specified
object is a set and having same size as the HashSet and contains all elements
that are present in HashSet comparing to.
- hashSet.equals(hashSet2); // returns true if specified object is a set
- //and having same size and contains all elements
How to check if HashSet contains specified element/elements -
contains() and containsAll()
HashSet provides two very important
methods, contains() returns true if the specified element is present in the
HashSet and containsAll() returns true if the elements in specified collection
are present in HashSet.
- hashSet.contains("element"); // return true if set contains specified element
- hashSet.containsAll(hashSet2); // return true if the hash set contains all the elements
- //specified in provided collection
How to convert Java HashSet to an Array or a String
toArray() converts all HashSet
elements to an array and toString() represents a String form of HashSet.
- hashSet.toArray(); // returns an array with hash set elements in it
- hashSet.toString(); // returns a string presentation of hash set elements
How to use retainAll with Hash Set in Java
retainAll() method returns only
those elements from HashSet that are present in the specified collection.
- hashSet.retainAll(hashSet2); // retain all elements that are present in specified collection
- // removes all elements that are not present in specified collection
How to get size of a Hash Set in Java
The size of a HashSet can be
obtained using .size() method, it returns an integer value equals to the number
of elements in the hash set.
- // check size of hash Set
- hashSet.size(); // returns an integer value
How to apply Iterator on a Java HashSet - iterator()
An iterator can be applied on a
HashSet instance using .iterator() method, iteration of HashSet does not retain
the order. hasNext() checks if the hash set contains more elements and .next()
returns the next element in hash set.
- Iterator<String> iterator = hashSet.iterator(); // returned an iterator on hash set -- no order
- while(iterator.hasNext()){
- System.out.println(iterator.next());
- }
HashSet
HashSet is backed by HashMap instance and it stores unique elements but order in which the elements are stored is not defined, it also allows null element.
The value that is added to the HashSet acts as a key to the backing HashMap with a dummy object as the value to that key which is a static constant so that multiple add operations does not result in multiple instances of object. For example if we add a value to the hashset like
Set<String> collections= new HashSet<String>();
collections.add("HashSet");
then internally it is stored in a map as hashmap.put("HashSet",dummy) where dummy is
private static final Object dummy = new Object();
When iterating over a HashSet a keyset iterator is returned not the values. Since the elements stored in the HashSet are stored as keys into the HashMap.
HashSet is backed by HashMap instance and it stores unique elements but order in which the elements are stored is not defined, it also allows null element.
The value that is added to the HashSet acts as a key to the backing HashMap with a dummy object as the value to that key which is a static constant so that multiple add operations does not result in multiple instances of object. For example if we add a value to the hashset like
Set<String> collections= new HashSet<String>();
collections.add("HashSet");
then internally it is stored in a map as hashmap.put("HashSet",dummy) where dummy is
private static final Object dummy = new Object();
When iterating over a HashSet a keyset iterator is returned not the values. Since the elements stored in the HashSet are stored as keys into the HashMap.
Set Implementation Internally in Java
Each and every element in the set is unique . So that there is no duplicate element in set .
So in java if we want to add elements in the set then we write code like this
Each and every element in the set is unique . So that there is no duplicate element in set .
So in java if we want to add elements in the set then we write code like this
public class Sunil {
public
static void
main(String[] args)
{
// TODO
Auto-generated method stub
HashSet<Object> hashset = new HashSet<Object>();
hashset.add(3);
hashset.add("Java");
hashset.add("Blogspot");
System.out.println("Set is "+hashset);
}
}
It will print the result : Set is [3, Java , Blogspot]
Now let add duplicate element in the above code
public class Sunil {
public
static void
main(String[] args)
{
HashSet<Object> hashset = new HashSet<Object>();
hashset.add(3);
hashset.add("Java");
hashset.add("Blogspot");
hashset.add(3); //
duplicate elements
hashset.add("Java");
// duplicate elements
System.out.println("Set is "+hashset);
}
}
It will print the result : Set is [3, Java, Blogspot]
Now , what happens internally when you pass duplicate elements in the add() method of the Set object , It will return false and do not add to the HashSet , as the element is already present .So far so good .
But the main problem arises that how it returns false . So here is the answer
When you open the HashSet implementation of the add() method in Java Api's that is rt.jar , you will find the following code in it
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable,
java.io.Serializable
{
private
transient HashMap<E,Object> map;
// Dummy value
to associate with an Object in the backing Map
private
static final
Object PRESENT = new
Object();
public
HashSet()
{
map =
new HashMap<>();
}
// SOME CODE
,i.e Other methods in Hash Set
public
boolean add(E e) {
return
map.put(e, PRESENT)==null;
}
// SOME CODE
,i.e Other methods in Hash Set
}
So , we are achieving uniqueness in Set,internally in java through HashMap . Whenever you create an object of HashSet it will create an object of HashMap as you can see in the italic lines in the above code .
As we know in HashMap each key is unique . So what we do in the set is that we pass the argument in the add(Elemene E) that is E as a key in the HashMap . Now we need to associate some value to the key , so what Java apis developer did is to pass the Dummy value that is ( new Object () ) which is referred by Object reference PRESENT .
So , actually when you are adding a line in HashSet like hashset.add(3) what java does internally is that it will put that element E here 3 as a key in the HashMap(created during HashSet object creation) and some dummy value that is Object's object is passed as a value to the key .
Now if you see the code of the HashMap put(Key k,Value V) method , you will find something like this
public V put(K key, V value) {
//Some code
}
The main point to notice in above code is that put (key,value) will return
1. null , if key is unique and added to the map
2. Old Value of the key , if key is duplicate
So , in HashSet add() method , we check the return value of map.put(key,value) method with null value
i.e.
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
So , if map.put(key,value) returns null ,then
map.put(e, PRESENT)==null will return true and element is added to the HashSet .
So , if map.put(key,value) returns old value of the key ,then
map.put(e, PRESENT)==null will return false and element is not added to the HashSet .
