WE PROVIDE ALL

» Unlabelled » Collections in Java

Collections in Java

0 comments

Collections :


         List is an interface and it contains Classes of ArrayList and Linked List.

Iterator interface

Iterator interface provides the facility of iterating the elements in forward direction only.

Methods of Iterator interface

There are only three methods in the Iterator interface. They are:
  1. public boolean hasNext() it returns true if iterator has more elements.
  2. public object next() it returns the element and moves the cursor pointer to the next element.
  3. public void remove() it removes the last elements returned by the iterator. It is rarely used.


ArrayList class


Java ArrayList class uses a dynamic array for storing the elements. It inherits AbstractList class and implements List interface.
The important points about Java ArrayList class are:
  • Java ArrayList class can contain duplicate elements.
  • Java ArrayList class maintains insertion order.
  • Java ArrayList class is non synchronized.
  • Java ArrayList allows random access because array works at the index basis.
  • In Java ArrayList class, manipulation is slow because a lot of shifting needs to be occurred if any element is removed from the array list.
Sample Program:
1.    import java.util.*;  
2.    class TestCollection1{  
3.     public static void main(String args[]){  
4.      ArrayList<String> list=new ArrayList<String>();//Creating arraylist  
5.      list.add("Ravi");//Adding object in arraylist  
6.      list.add("Vijay");  
7.      list.add("Ravi");  
8.      list.add("Ajay");  
9.      //Traversing list through Iterator  
10.   Iterator itr=list.iterator();  
11.   while(itr.hasNext()){  
12.    System.out.println(itr.next());  
13.   }  
14.  }  
15. }  

OutPut:
Ravi
Vijay
Ravi
Ajay

Two ways to iterate the elements of collection in java

There are two ways to traverse collection elements:
  1. By Iterator interface.
  2. By for-each loop.
In the above example, we have seen traversing ArrayList by Iterator. Let's see the example to traverse ArrayList elements using for-each loop.
1.    import java.util.*;  
2.    class TestCollection2{  
3.     public static void main(String args[]){  
4.      ArrayList<String> al=new ArrayList<String>();  
5.      al.add("Ravi");  
6.      al.add("Vijay");  
7.      al.add("Ravi");  
8.      al.add("Ajay");  
9.      for(String obj:al)  
10.     System.out.println(obj);  
11.  }  
12. } 
OutPut:
Ravi
Vijay
Ravi
Ajay

Example of addAll(Collection c) method:


1.    import java.util.*;  
2.    class TestCollection4{  
3.     public static void main(String args[]){  
4.      ArrayList<String> al=new ArrayList<String>();  
5.      al.add("Ravi");  
6.      al.add("Vijay");  
7.      al.add("Ajay");  
8.      ArrayList<String> al2=new ArrayList<String>();  
9.      al2.add("Sonoo");  
10.   al2.add("Hanumat");  
11.   al.addAll(al2);//adding second list in first list  
12.   Iterator itr=al.iterator();  
13.   while(itr.hasNext()){  
14.    System.out.println(itr.next());  
15.   }  
16.  }  
17. }  

Output:
Ravi
Vijay
Ajay
Sonoo
Hanumat


Example of removeAll() method:


1.    import java.util.*;  
2.    class TestCollection5{  
3.     public static void main(String args[]){  
4.      ArrayList<String> al=new ArrayList<String>();  
5.      al.add("Ravi");  
6.      al.add("Vijay");  
7.      al.add("Ajay");  
8.      ArrayList<String> al2=new ArrayList<String>();  
9.      al2.add("Ravi");  
10.   al2.add("Hanumat");  
11.   al.removeAll(al2);  
12.   System.out.println("iterating the elements after removing the elements of al2...");  
13.   Iterator itr=al.iterator();  
14.   while(itr.hasNext()){  
15.    System.out.println(itr.next());  
16.   }  
17.   
18.   }  
19. }  

Output:

iterating the elements after removing the elements of al2…
Vijay
Ajay

LinkedList class


The important points about Java LinkedList are:
  • Java LinkedList class can contain duplicate elements.
  • Java LinkedList class maintains insertion order.
  • Java LinkedList class is non synchronized.
  • In Java LinkedList class, manipulation is fast because no shifting needs to be occurred.
  • Java LinkedList class can be used as list, stack or queue.

 LinkedList Example


1.    import java.util.*;  
2.    public class TestCollection{  
3.     public static void main(String args[]){  
4.      
5.      LinkedList<String> al=new LinkedList<String>();  
6.      al.add("Ravi");  
7.      al.add("Vijay");  
8.      al.add("Ravi");  
9.      al.add("Ajay");  
10.   
11.   Iterator<String> itr=al.iterator();  
12.   while(itr.hasNext()){  
13.    System.out.println(itr.next());  
14.   }  
15.  }  
16. }  

Output:
Ravi
Vijay
Ravi
Ajay





Linked List Example:

package oops;

import java.util.LinkedList;

public class TestCollection {

      public static void main(String[] args) {
            LinkedList <String>li=new LinkedList<String>();
            li.add("Ajay");
            li.addLast("Hari");
            li.add("Bala");
            li.addFirst("Satish");
           
         String s1=li.getFirst();
      System.out.println("The First element is "+s1);
           
            for(String s: li)
            {
                  System.out.println("The elements in the list are  "+s);
            }
      }
}

Output:
The First element is Satish
The elements in the list are  Satish
The elements in the list are  Ajay
The elements in the list are  Hari
The elements in the list are  Bala

Queue:
Java Queue interface orders the element in FIFO(First In First Out) manner. In FIFO, first element is removed first and last element is removed at last.

 Object poll():
It is used to retrieves and removes the head of this queue, or returns null if this queue is empty.

Queue Interface declaration:


public interface Queue<E> extends Collection<E>  
Example:
1.    import java.util.*;  
2.    class TestCollection12{  
3.    public static void main(String args[]){  
4.    PriorityQueue<String> queue=new PriorityQueue<String>();  
5.    queue.add("Amit");  
6.    queue.add("Vijay");  
7.    queue.add("Karan");  
8.    queue.add("Jai");  
9.    queue.add("Rahul");  
10. System.out.println("head:"+queue.element());  
11. System.out.println("head:"+queue.peek());  
12. System.out.println("iterating the queue elements:");  
13. Iterator itr=queue.iterator();  
14. while(itr.hasNext()){  
15. System.out.println(itr.next());  
16. }  
17. queue.remove();  
18. queue.poll();  
19. System.out.println("after removing two elements:");  
20. Iterator<String> itr2=queue.iterator();  
21. while(itr2.hasNext()){  
22. System.out.println(itr2.next());  
23. }  
24. }  
25. }  

Output:
Output:head:Amit
       head:Amit
       iterating the queue elements:
       Amit
       Jai
       Karan
       Vijay
       Rahul
       after removing two elements:
       Karan
       Rahul
       Vijay

Set:
    
Set is an interface,In set the classes are Hashset and  Treeset.

Java HashSet class is used to create a collection that uses a hash table for storage. It inherits the AbstractSet class and implements Set interface.
The important points about Java HashSet class are:
  • HashSet stores the elements by using a mechanism called hashing.
  • HashSet contains unique elements only.


1.    import java.util.*;  
2.    class TestCollection9{  
3.     public static void main(String args[]){  
4.      //Creating HashSet and adding elements  
5.      HashSet<String> set=new HashSet<String>();  
6.      set.add("Ravi");  
7.      set.add("Vijay");  
8.      set.add("Ravi");  
9.      set.add("Ajay");  
10.   //Traversing elements  
11.   Iterator<String> itr=set.iterator();  
12.   while(itr.hasNext()){  
13.    System.out.println(itr.next());  
14.   }  
15.  }  
16. }  

Output:

Ajay
Vijay
Ravi




 
TreeSet

Java TreeSet class implements the Set interface that uses a tree for storage. It inherits AbstractSet class and implements NavigableSet interface. The objects of TreeSet class are stored in ascending order.
The important points about Java TreeSet class are:
  • Contains unique elements only like HashSet.
  • Access and retrieval times are quiet fast.
  • Maintains ascending order.

import java.util.*;
class TestCollection9{ 
 public static void main(String args[]){ 
  //Creating HashSet and adding elements 
       
       TreeSet<Integer> al=new TreeSet<Integer>(); 
        al.add(100); 
        al.add(98); 
        al.add(67); 
        al.add(50); 
       
        //Traversing elements 
        Iterator<Integer> itr=al.iterator(); 
        while(itr.hasNext()){ 
         System.out.println(itr.next()); 
     } 
}
}

Output:
50
67
98
100




import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetExample {

   public static void main(String[] args) {
        System.out.println("Tree Set Example!\n");
        TreeSet<Integer> tree = new TreeSet<Integer>();
        tree.add(12);
        tree.add(63);
        tree.add(34);
        tree.add(45);

        // here it test it's sorted, 63 is the last element. see output below
        Iterator<Integer> iterator = tree.iterator();
        System.out.print("Tree set data: ");

        // Displaying the Tree set data
        while (iterator.hasNext()) {
               System.out.print(iterator.next() + " ");
        }
        System.out.println();

        // Check empty or not
        if (tree.isEmpty()) {
               System.out.print("Tree Set is empty.");
        } else {
               System.out.println("Tree Set size: " + tree.size());
        }

        // Retrieve first data from tree set
        System.out.println("First data: " + tree.first());

        // Retrieve last data from tree set
        System.out.println("Last data: " + tree.last());

        if (tree.remove(45)) { // remove element by value
               System.out.println("Data is removed from tree set");
        } else {
               System.out.println("Data doesn't exist!");
        }
        System.out.print("Now the tree set contain: ");
        iterator = tree.iterator();

        // Displaying the Tree set data
        while (iterator.hasNext()) {
               System.out.print(iterator.next() + " ");
        }
        System.out.println();
        System.out.println("Now the size of tree set: " + tree.size());

        // Remove all
        tree.clear();
        if (tree.isEmpty()) {
               System.out.print("Tree Set is empty.");
        } else {
               System.out.println("Tree Set size: " + tree.size());
        }
   }
}
Output:
Treeset  Example
Tree set Data :12 34 45 63
Tree set size : 4
First  Data: 12
Last Data: 63
Data is removed from the  Treeset
Now the  tree set contain : 12  34 63
Now the size of tree set : 3
Tree set is Empty.


HashMap:
Java HashMap class implements the map interface by using a hashtable. It inherits AbstractMap class and implements Map interface.
The important points about Java HashMap class are:
  • A HashMap 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.

HashMap class Parameters

Let's see the Parameters for java.util.HashMap class.
  • K: It is the type of keys maintained by this map.
  • V: It is the type of mapped values.


Methods:
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.


1.    import java.util.*;  
2.    class TestCollection13{  
3.     public static void main(String args[]){  
4.      HashMap<Integer,String> hm=new HashMap<Integer,String>();  
5.      hm.put(100,"Amit");  
6.      hm.put(101,"Vijay");  
7.      hm.put(102,"Rahul");  
8.      for(Map.Entry m:hm.entrySet()){  
9.       System.out.println(m.getKey()+" "+m.getValue());  
10.   }  
11.  }  
12. }  

Output :
102 Rahul
100 Amit
101 Vijay




import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;
public class Details {

   public static void main(String args[]) {

      /* This is how to declare HashMap */
      HashMap<Integer, String> hmap = new HashMap<Integer, String>();

      /*Adding elements to HashMap*/
      hmap.put(12, "Chaitanya");
      hmap.put(2, "Rahul");
      hmap.put(7, "Singh");
      hmap.put(49, "Ajeet");
      hmap.put(3, "Anuj");

      /* Display content using Iterator*/
      Set set = hmap.entrySet();
      Iterator iterator = set.iterator();
      while(iterator.hasNext()) {
         Map.Entry mentry = (Map.Entry)iterator.next();
         System.out.print("key is: "+ mentry.getKey() + " & Value is: ");
         System.out.println(mentry.getValue());
      }

      /* Get values based on key*/
      String var= hmap.get(2);
      System.out.println("Value at index 2 is: "+var);

      /* Remove values based on key*/
      hmap.remove(3);
      System.out.println("Map key and values after removal:");
      Set set2 = hmap.entrySet();
      Iterator iterator2 = set2.iterator();
      while(iterator2.hasNext()) {
          Map.Entry mentry2 = (Map.Entry)iterator2.next();
          System.out.print("Key is: "+mentry2.getKey() + " & Value is: ");
          System.out.println(mentry2.getValue());
       }

   }
}
Output:
key is: 49 & Value is: Ajeet
key is: 2 & Value is: Rahul
key is: 3 & Value is: Anuj
key is: 7 & Value is: Singh
key is: 12 & Value is: Chaitanya
Value at index 2 is: Rahul
Map key and values after removal:
Key is: 49 & Value is: Ajeet
Key is: 2 & Value is: Rahul
Key is: 7 & Value is: Singh
Key is: 12 & Value is: Chaitanya

The Map.Entry interface enables you to work with a map entry.
The entrySet( ) method declared by the Map interface returns a Set containing the map entries. Each of these set elements is a Map.Entry object.


TreeMap:
Java TreeMap class implements the Map interface by using a tree. It provides an efficient means of storing key/value pairs in sorted order.
The important points about Java TreeMap class are:
  • A TreeMap contains values based on the key. It implements the NavigableMap interface and extends AbstractMap class.
  • It contains only unique elements.
  • It cannot have null key but can have multiple null values.
  • It is same as HashMap instead maintains ascending order.
Example:
1.    import java.util.*;  
2.    public class TreeMapExample {  
3.       public static void main(String args[]) {  
4.       // Create and populate tree map  
5.       Map<Integer, String> map = new TreeMap<Integer, String>();           
6.       map.put(102,"Let us C");  
7.       map.put(103, "Operating System");  
8.       map.put(101, "Data Communication and Networking");  
9.       System.out.println("Values before remove: "+ map);    
10.    // Remove value for key 102  
11.    map.remove(102);  
12.    System.out.println("Values after remove: "+ map);  
13.    }      
14. }  

Output:
Values before remove: {101=Data Communication and Networking, 102=Let us C, 103=Operating System}
Values after remove: {101=Data Communication and Networking, 103=Operating System}




Categories:
Pin It

Related Post:



0 comments:

Post a Comment

Copyright © 2013 Jobs And Technology | Blog Powered by Blogger | Designed by Free Premium Software | WordPress Hosting Reviews