Thursday, 5 June 2014

Collection Related Interview Questions and Answers in Java(List,Map & Set)

            In every Java interview, the interviewer will ask the collection questions,  Mostly on ArrayList,HashMap,LinkedList,LinkedHashMap,LinkedHashSet and so on.
           Here i have shared some interview questions and answers which i faced in an interview.

1)  What is the difference between Collection and Collections ?
          
       Collection is an interface while Collections is a Java class, both are present in java.util package and a part of java collections framework.

2) Why Map Interface doesn't extend Collection interface?

      Refer this link, Why Map interface doesn't extend Collection interface?


3) What are the classes implementing List and Set interface?

      ArrayList, Vector and LinkedList classes are implementing List interaface. HashSet and TreeSet classes are implementing Set interface.


4) Which collection classes are thread safe ?

          Vector, Hashtable, Properties and Stack are synchronized classes, so they are thread safe and can be used in multi-threaded environment.


5) How HashMap works internally in Java ?

           This is one of the most important question for Java Developers. HashMap works on the principle of Hashing. For Detailed information How HashMap works internally in java.


6) How to convert the array of Strings into the list ?

           Arrays class of java.util package contains the method asList() which accepts the array as parameter.

                        String arr[] = {"Insta", "Practo"};
                        List listOfString = Arrays.asList(arr);



7) How to make a collection read only ?
        
       Use following methods to make a collection read only,

                       Collections.unmodifiableList(list);
                       Collections.unmodifiableSet(set);
                       Collections.unmodifiableMap(map);


8) How to make a collection thread safe ?
      
      Use following methods to make a collection thread safe,

                       Collections.synchronizedList(list);
                       Collections.synchronizedMap(map);
                       Collections.synchronizedSet(set);


9) Difference between HashMap and Hashtable in java.
     
     Refer this Difference between HashMap and Hashtable in collection in Java


10) Difference between ConcurrenHashMap and Hashtable.

       Both ConcurrentHashMap and Hashtable are synchronization in nature. For consideration of performance, ConcurrentHashMap is good because it is locked the particular segment but in Hashtable it will lock the whole object.


11) Difference between the HashMap, LinkedHashMap and TreeMap.

       All these three classes can implement the java.util.Map interface. Differences are as follows,

        HashMap can not maintain any order for inserting key or for getting key from map. But in LinkedHashMap , it can maintain the same insertion order. TreeMap can give the Natural order.

        HashMap can allow one null key and multiple null values, LinkedHashMap also can allow one null key and multiple null values. But TreeMap doesn't allow the null keys.
     

12)  How ArrayList works internally in Java?

   I have written separate post for internal working concept of ArrayList in Collection, Refer  Internal Implementation of ArrayList


13) What are the different ways to iterate over the list ?

        There are two ways to iterate over a list - using for-each loop and another one using iterator interface.
   
             ArrayList<String> arrList = new ArrayList<String>();
          
              //using for-each loop
             for  (String name : arrList )  {
                    System.out.println(name);
             }
   
              //using iterator interface
             Iterator<String>  iterator = arrList.iterator();
             while (iterator.hasNext()) {
                     System.out.println(iterator.next());
             }


14) What is fail-fast & fail-safe property in Iterator?

          In fail-fast property, every time while iterating the list it will check for the modification in the list, If any modification found then it will throw ConcurrentModificationException errors. All the implementations of iterator in Collection classes are fail-fast except concurrent classes like ConcurrentHashMap and CopyOnWriteArrayList.
          
          In fail-safe property, while iterating the list it won't throw any exception i.e ConcurrentModificationException even if you modified the list. All implementations of Collection classes in java.util package are fail-fast and all Collections classes of java.util.concurrent are fail-safe.
Examples of fail-safe classes are ConcurrentHashMap and CopyOnWriteArrayList.



15)  HashMap Related Question--

                        HashMap<String,String> map=new HashMap<String,String>();
                        map.put("one", new Integer(1));
                        map.put("one", new Float(1.0));
                        System.out.println(map.get("one"));

                In which value it will print? 1 or 1.0?

  It will print 1.0 because if map having the same keys then it can override
                the previous key value. 


16) See below code--

                        HashMap<String,Integer> map=new HashMap<String,Integer>();
                        String s="anil";
                        map.put(s,1);
                        s=s+"nivargi";
                        System.out.println(map.get(s));

                     what would be the output?will give error or what?

     Output is -  null.


17)  How to loop or iterate the Map or HashMap in java?Explain
  
     There are two ways (i know) to iterate the Map or HashMap
                     1)Using iterator interface
                     2)using Enhanced for loop
      See below code------
       Here you can use Map.Entry interface .
                           package com.adnblog;
                           import java.util.HashMap;
                           import java.util.Iterator;
                           import java.util.Map;
                           public class ItertionMap{
                                      public static void main(String[] args){
                                                   Map<String,String> map=
                                                                             new HashMap<String,String>();
                                                    map.put("1","one");
                                                    map.put("2","two");
                                                    map.put("3","three");
                                                          //first type i.e using iterator interface
                                                    Iterator iterator=map.entrySet().iterator();
                                                    while(iteartor.hasNext()){
                                                              Map.Entry mapEntry=
                                                                                (Map.Entry)iterator.next();
                                                              System.o.p("key--"+mapEntry.getKey()+
                                                                                "value "+mapEntry.getValue());
                                                    }                     
                                                            //second type using forEach loop
                                                    for(Map.Entry<String,String> entry: map.entrySet()){
                                                                System.out.println("key--"+entry.getKey()+
                                                                                  "value "+entry.getValue());
                                                    } 
                                    }
                          }

18) What is UnsupportedOperationException in Collection ? and when it will throw?

            The Exception itself indicates that given operation is not supported. This will throw when we are modifying the unmodifiable collection.
            e.g
                   List<String> list = new ArrayList<String>();
                   list.add("Insta");
                   List<String> unmodifiableList = Collections.unmodifiableList(list);
                   unmodifiableList.add("Practo");       //will throw the exception. 
                

 19) What is ConcurrentModificationException in collection? in which situation it will  come? give me example.   
             
           The java.util Collection classes are fail-fast, which means that if one thread changes a collection while another thread is traversing it through with an iterator the iterator.hasNext() or iterator.next() call will throw  ConcurrentModificationException This situation can come in case of  multithreaded as well as single threaded environment. 
          Lets see the scenario with an example:

                             import java.util.*;
                             public class IteratorEx{
                                     public static void main(String[] args){
                                              List<String> list=new ArrayList<String>();
                                              list.add("one");
                                              list.add("two");
                                              list.add("three");
                                              Iterator<String>  it=list.iterator();
                                              while(it.hasNext()){
                                                      String key=it.next();
                                                       if(key.equals("two")){
                                                              list.remove("two");    //will throw error
                                                       }
                                             }
                                     }
                            }

                 How to handle the
ConcurrentModificationException:--

1)  The list can be converted to an array with list.toArray() and iterate on the array.  This approach  is not recommended if the list is large. 

2)  You can lock the list while iterating by putting it in a synchronized block. This approach is not recommended because it will cease the benefits of  multithreading .

3) If you are using JDK1.5 or higher then you can use ConcurrentHashMap and CopyOnWriteArrayList classes. It is the recommended approach.

4)  if you are removing element from collection then use iterator remove method instead of collection remove method .


Related Post:-- 
Internal implementation of ArrayList in Java  
 

No comments:

Post a Comment