CollectionFramework-Part-2 In Java

Iterators in Java

Iterator is used to iterator over collection of objects.

Iterator is interface.

package Test;

import java.util.ArrayList;

import java.util.Iterator;

public class Example2 {

           

      /**

     * Returns { true} if the iteration has more elements.

     * (In other words, returns {true} if {next} would

     * return an element rather than throwing an exception.)

     *

     * @return {@code true} if the iteration has more elements

     */

            public static void main(String[] args) {

                        ArrayList<Integer> array = new ArrayList<Integer>();

                        array.add(3);

                        array.add(4);

                        array.add(5);

                       

                        Iterator<Integer> itr = array.iterator();

                        while(itr.hasNext()){

                                    System.out.println(itr.next());

                        }

            }          

}

/*

Output: -

3

4

5

*/

Iterator Methods

·      boolean hasNext();

·      E next ();

·      void remove ();

boolean   hasNext()

·      Returns true if the iteration has more elements.

E    next ()

·      Returns the next element in the iteration.

void   remove ()

·      Removes from the underlying collection the last element returned by this iterator (optional operation).

boolean hasNext()

·      Returns true if the iteration has more elements. (In other words, returns true if next () would return an element rather than throwing an exception.)

·      Returns: true if the iteration has more elements

Methods in More Details:

E next ()

·      Returns the next element in the iteration.

·      Returns: the next element in the iteration

·      Throws:NoSuchElementException - if the iteration has no more elements

void remove ()

·      Removes from the underlying collection the last element returned by this iterator (optional operation). This method can be called only once per call to next ().

·      The behavior of an iterator is unspecified if the underlying collection is modified while the iteration is in progress in any way other than by calling this method.

·      Throws:UnsupportedOperationException - if the remove operation is not supported by this iterator.

·      IllegalStateException - if the next method has not yet been called, or the remove method has already been called after the last call to the next method.

Example2: Iterate over Linked List

package Test;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

public class Example2 {

            public static void main(String[] args) {

                        List<Integer> array = new LinkedList<Integer>();

                        array.add(3);

                        array.add(4);

                        array.add(5);

                       

                        Iterator<Integer> itr = array.iterator();

                        while(itr.hasNext()){

                                    System.out.println(itr.next());

                        }

            }          

}

List Iterator

It is used to Iterator over collection of object.

List Iterator Methods

boolean hasNext();

E next ();

boolean hasPrevious();

E previous ();

void remove ();

/**

 * Returns the previous element in the list and moves the cursor

 * position backwards.

*/

boolean hasPrevious();

/**

Return the previous element from list

*/

E previous();

/**

 * Returns the next element in the list and advances the cursor position.

 * This method may be called repeatedly to iterate through the list,

 */

boolean hasNext();

/**

 * Return the element for collection objects

 * @return

 */

E next();

void remove();

package Test;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

public class Example2 {

            public static void main(String[] args) {

                       

                        List<Integer> array = new LinkedList<Integer>();

                        array.add(3);

                        array.add(42);

                        array.add(51);

                        array.add(50);

                        array.add(9);

                        ListIterator<Integer> itr = array.listIterator();

                        while(itr.hasNext()){

                                    System.out.println(itr.next());

                        }

                        System.out.println("Now we will get previous elements from last to first");

                        while(itr.hasPrevious()){

                                    System.out.println(itr.previous());

                        }

            }          

}

Output: -

3

42

51

50

9

Now we will get previous elements from last to first

9

50

51

42

3

package Test;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

public class Example2 {

            public static void main(String[] args) {

                       

                        List<Integer> array = new LinkedList<Integer>();

                        array.add(3);

                        array.add(42);

                        array.add(51);

                        array.add(50);

                        array.add(9);

                       

        // listIterator() will give list of ListIterator

                        ListIterator<Integer> itr = array.listIterator();

                        // hasNext() will check the object in collection and move the pointer to next objects

                        while(itr.hasNext()){

                                    // itr.next() will return next element

                                    System.out.println(itr.next());

                        }

                        System.out.println("Now we will get previous elements from last to first");

                        // hasPrevious() will check the previous object from current point and move the

                        // Pointer to previous

                        while(itr.hasPrevious()){

                                    // itr.previous() will return previous element

                                    System.out.println(itr.previous());

                        }

                        // Once we reach to the previous elements, again we are Iterating

                        // And calling remove method. Remove method will return one by one

                        while(itr.hasNext()){

                                    // remove(); will remove object from collection of objects

                                    itr.remove();

                        }

            }          

}

Set in Java

Points to know:

1)    Set will store only unique data

2)    Hash Set will not maintain insertion order.

Methods and Constructors of Hash Set

Constructor	Description
HashSet()	It is used to construct a default HashSet.
HashSet(Collection c)	It is used to initialize the hash set by using the elements of the collection c.
HashSet(int capacity)	It is used to initialize the capacity of the hash set to the given integer value capacity. The capacity grows automatically as elements are added to the HashSet.
Methods of Java HashSet class:
Method	Description
boolean isEmpty()	It is used to return true if this set contains no elements.
boolean remove(Object o)	It is used to remove the specified element from this set if it is present.
Object clone()	It is used to return a shallow copy of this HashSet instance: the elements themselves are not cloned.
Iterator iterator()	It is used to return an iterator over the elements in this set.
int size()	It is used to return the number of elements in this set.
void clear()	It is used to remove all of the elements from this set.
boolean contains(Object o)	It is used to return true if this set contains the specified element.
boolean add(Object o)	It is used to adds the specified element to this set if it is not already present.

Example of Has Set

package Test;

import java.util.HashSet;

import java.util.Set;

public class ExampleHashSet {

           

            public static void main(String[] args) {

                        // Hash Set will store Only unique data.

                        Set<Integer> set = new HashSet<Integer>();

                        set.add(1);

                        set.add(1);

                        set.add(10);

                        set.add(7);

                        set.add(80);

                        set.add(8);

                        set.add(8);

                        // insertion order are not maintained

                        System.out.println(set);

            }

}

//output: [1, 80, 7, 8, 10]

Iterator on Hash Set

package Test;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

public class ExampleHashSet {

           

            public static void main(String[] args) {

                        // Hash Set will store Only unique data.

                        Set<Integer> set = new HashSet<Integer>();

                        set.add(1);

                        set.add(1);

                        set.add(10);

                        set.add(7);

                        set.add(80);

                        set.add(8);

                        set.add(8);

                        // insertion order are not maintained

                        // We can use iterator to iterate over the set, since get method is not supported.

                        // We cannot use set.get(0)

                        Iterator<Integer> itr = set.iterator();

                        while(itr.hasNext()){

                                    System.out.println(itr.next());

                        }

            }

}

//output

1

80

7

8

10

Linked Hash set will maintain insertion order.

package Test;

import java.util.LinkedHashSet;

import java.util.Set;

public class ExampleHashSet {

           

            public static void main(String[] args) {

                        Set<Integer> set = new LinkedHashSet<Integer>();

                        set.add(1);

                        set.add(1);

                        set.add(10);

                        set.add(7);

                        set.add(80);

                        set.add(8);

                        set.add(8);

                        System.out.println(set);

            }

}

//output: [1, 10, 7, 80, 8]

Tree Set Maintain the data in ascending order.

package Test;

import java.util.Set;

import java.util.TreeSet;

public class ExampleHashSet {

           

            public static void main(String[] args) {

                        Set<Integer> set = new TreeSet<Integer>();

                        set.add(1);

                        set.add(1);

                        set.add(10);

                        set.add(7);

                        set.add(80);

                        set.add(8);

                        set.add(8);

                        System.out.println(set);

            }

}

//output: [1, 7, 8, 10, 80]

Map in collection

·      Map will not maintain insertion order.

·      Map will store data based on key value pair

·      Map will store only unique data.

·       

Hash Map

·      A Hash Map contains values based on the key.

·      It contains only unique elements.

·      It may have one null key and multiple null values.

·      It maintains no order.

Constructors of Java Hash Map class
Constructor	Description
HashMap()	It is used to construct a default HashMap.
HashMap(Map m)	It is used to initializes the hash map by using the elements of the given Map object m.
HashMap(int capacity)	It is used to initializes the capacity of the hash map to the given integer value, capacity.
HashMap(int capacity, float fillRatio)	It is used to initialize both the capacity and fill ratio of the hash map by using its arguments.
Methods of Java Hash Map class
Method	Description
void clear()	It is used to remove all of the mappings from this map.
boolean containsKey(Object key)	It is used to return true if this map contains a mapping for the specified key.
boolean containsValue(Object value)	It is used to return true if this map maps one or more keys to the specified value.
boolean isEmpty()	It is used to return true if this map contains no key-value mappings.
Object clone()	It is used to return a shallow copy of this HashMap instance: the keys and values themselves are not cloned.
Set entrySet()	It is used to return a collection view of the mappings contained in this map.
Set keySet()	It is used to return a set view of the keys contained in this map.
Object put(Object key, Object value)	It is used to associate the specified value with the specified key in this map.
int size()	It is used to return the number of key-value mappings in this map.
Collection values()	It is used to return a collection view of the values contained in this map.

Example:

package Test;

import java.util.HashMap;

import java.util.Map;

public class ExampleHashSet {

           

            public static void main(String[] args) {

                        Map<Integer,Integer> map = new HashMap<Integer,Integer>();

                        map.put(1, 100);

                        map.put(20, 100);

                        map.put(30, 100);

                        map.put(4, 100);

                        System.out.println(map);

            }

}

//output: {1=100, 4=100, 20=100, 30=100}

Hash Map will store one null key.

package Test;

import java.util.HashMap;

import java.util.Map;

public class ExampleHashSet {

           

            public static void main(String[] args) {

                        Map<Integer,Integer> map = new HashMap<Integer,Integer>();

                        map.put(1, 100);

                        map.put(20, 100);

                        map.put(30, 100);

                        map.put(30, 100);

                        map.put(30, 100);

                        map.put(30, 100);

                        map.put(null, 100);

                        System.out.println(map);

            }

}

//output: {null=100, 1=100, 20=100, 30=100}

To get Data from Hash Map we have use method “get”

           

            /**

     * Returns the value to which the specified key is mapped,

     * or null if this map contains no mapping for the key.

     */

package Test;

import java.util.HashMap;

import java.util.Map;

public class ExampleHashSet {

            public static void main(String[] args) {

                        Map<Integer,Integer> map = new HashMap<Integer,Integer>();

                        map.put(1, 100);

                        map.put(20, 100);

                        map.put(30, 400);

                        map.put(30, 100);

                        map.put(30, 600);

                        map.put(30, 100);

                        map.put(null, 100);

                        System.out.println(map.get(1));

                        System.out.println(map.get(20));

                        System.out.println(map.get(30));

            }

}

//output:

100

100

100

Linked Hash Map will maintain insertion order

Example

package Test;

import java.util.LinkedHashMap;

import java.util.Map;

public class ExampleHashSet {

           

            public static void main(String[] args) {

                        Map<Integer,Integer> map = new LinkedHashMap<Integer,Integer>();

                        map.put(1, 100);

                        map.put(20, 100);

                        map.put(30, 100);

                        map.put(4, 100);

                        System.out.println(map);

            }

}

//output: {1=100, 20=100, 30=100, 4=100}

Tree Map will store the data in ascending order

package Test;

import java.util.Map;

import java.util.TreeMap;

public class ExampleHashSet {

           

            public static void main(String[] args) {

                        Map<Integer,Integer> map = new TreeMap<Integer,Integer>();

                        map.put(1, 100);

                        map.put(20, 100);

                        map.put(30, 100);

                        map.put(4, 100);

                        System.out.println(map);

            }

}

//output: {1=100, 4=100, 20=100, 30=100}

Hash Table

·      Hash Table is thread safe.

·      We cannot store null key in hash table

·      It will not insertion order.

Example

package Test;

import java.util.Hashtable;

public class HashTableInJava {

           

            public static void main(String[] args) {

                        Hashtable<Integer,Integer> obj = new Hashtable<Integer,Integer>();

                        obj.put(1, 900);

                        obj.put(2, 800);

                        obj.put(3, 600);

                        obj.put(4, 400);

                        obj.put(5, 900);

                        System.out.println(obj);

            }

}

// Output: - {5=900, 4=400, 3=600, 2=800, 1=900}