This Post totally some practical programs for understanding collections.

1)    How to count same name in two lists in java application.

R)

import java.util.ArrayList;

import java.util.List;

/**

* @author Chandra Sekhar

*/

public class SameNameCountList

 {

          public static void main(String[] args)

      {

                    int count=0;

                    List list1 = new ArrayList();

                    list1.add("chandra");

                    list1.add("siva");

                    list1.add("murali");

                    list1.add("ramana");

         

                    List list2 = new ArrayList();

                    list2.add("sekhar");

                    list2.add("charan");

                    list2.add("chandra");

                    list2.add("madhavi");

         

                    for(Object o:list1)

                    {

                              if(list2.contains(o))

                              {

                                       count++;    

                              }

                  

                    }

                    System.out.println("same name contains two list "+count);

          }

}

O/P: same name contains two lists 1

2)    I want to retrieve all the objects present in  list2 which is present in list1 also and remove them from list2?

R)

import java.util.ArrayList;

import java.util.List;

/**

 * I want to retreive all the objects present in

 * list2 which is present in list1 also and remove them from list2.

 * @author ChandraSekhar

 *

 */

public class Listretain

{

          public static void main(String[] args)

 {

                   //add element’s to list1

List l1 = new ArrayList();

                   l1.add("charan");

                   l1.add("madhavi");

                   l1.add("chandra");

                   l1.add("anji");

                   l1.add("suguna");

                   //add element’s to list2

                   List l2 = new ArrayList();

                   l2.add("murali");

                   l2.add("sirisha");

                   l2.add("vasanth");

                   l2.add("praneetha");

                   l2.add("anji");

                   l2.add("suguna");

                   //retrieve retain list

                   List retrieve= new ArrayList(l2);

                   retrieve.retainAll(l1);

                  

                   System.out.println("List one "+l1);

                  

                   System.out.println("Second List "+l2);

                  

                   System.out.println("Retrieve List "+retrieve);

          }

}

O/p

List one [charan, madhavi, chandra, anji, suguna]

Second List [murali, sirisha, vasanth, praneetha, anji, suguna]

Retrieve List [anji, suguna]

Q) How to Compares two String or number lists or a list that contains either strings or number and then prints out a list of  items that are in first list but not in the second list and also a    list of items that are in second list but not in the first list

R)

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

/**

 *          @author Chandra Sekhar

 *         This simple utility compares two String or number lists or a list

 *         that contains either strings or number and then prints out a list

 *         items that are in first list but not in the second list and also a

 *         list of items that are in second list but not in the first list.

 */

public class ListCompare {

          public static void main(String args[]) {

                    List listA = new ArrayList();

                    listA.add(1);

                    listA.add(2);

                    listA.add("Kushal");

                    listA.add("Madan");

                    listA.add("Pooja");

                    listA.add("Kripa");

                    List listB = new ArrayList();

                    listB.add(2);

                    listB.add(3);

                    listB.add("Kushal");

                    listB.add("Madan");

                    listB.add("Jenny");

                    listB.add("Betsy");

                    ListCompare listComp = new ListCompare();

                    listComp.compareLists(listA, listB);

          }

          public void compareLists(List firstList, List secondList) {

                    Map mapForFirstList = new HashMap();

                    Map mapForSecondList = new HashMap();

                    Iterator firstListIterator = firstList.iterator();

                    Iterator secondListIterator = secondList.iterator();

                    while (firstListIterator.hasNext()) {

                              String firstListKeyValue = firstListIterator.next().toString();

                              /**

                               * Put the value from the list into the map, only if the same value

                               * already does not exists. That means if there are duplicates, we

                               * put only one instance into the hashmap.

                               */

                              if (!mapForFirstList.containsKey(firstListKeyValue)) {

                                        mapForFirstList.put(firstListKeyValue, firstListKeyValue);

                              }

                    }

                    while (secondListIterator.hasNext()) {

                              String secondListKeyValue = secondListIterator.next().toString();

                              /**

                               * Put the value from the list into the map, only if the same value

                               * already does not exists. That means if there are duplicates, we

                               * put only one instance into the hashmap.

                               */

                              if (!mapForSecondList.containsKey(secondListKeyValue)) {

                                        mapForSecondList.put(secondListKeyValue, secondListKeyValue);

                              }

                    }

                    compareAndPrintResults(mapForFirstList, mapForSecondList);

          }

          private void compareAndPrintResults(Map mapForFirstList,

                              Map mapForSecondList) {

                    /** Compare first map against the second one and print the difference **/

                    printItemsFromFirstListThatAreNotOnSecondList(mapForFirstList,

                                        mapForSecondList);

                    /** Compare second map against the first and print the difference */

                    printItemsFromSecondListThatAreNotOnFirstList(mapForSecondList,

                                        mapForFirstList);

          }

          private void printItemsFromFirstListThatAreNotOnSecondList(Map mapA,

                              Map mapB) {

                    System.out

                                        .println("***Items from first list that are not in second list");

                    doComparisionAndPrint(mapA, mapB);

          }

          private void printItemsFromSecondListThatAreNotOnFirstList(Map mapA,

                              Map mapB) {

                    System.out

                                        .println("***Items from second list that are not in firstList list");

                    doComparisionAndPrint(mapA, mapB);

          }

          /**

           * @param mapA

           * @param mapB

           *

           *            This method compares two hashmaps and prints out the values

           *            from the first one that are not in the second one.

           */

          private void doComparisionAndPrint(Map mapA, Map mapB) {

                    // both maps should be non-empty for comparison.

                    if (mapA != null && mapB != null) {

                              Iterator mapAIterator = mapA.keySet().iterator();

                              while (mapAIterator.hasNext()) {

                                        String key = mapAIterator.next().toString();

                                        if (!mapB.containsKey(key)) {

                                                  System.out.println(key);

                                        }

                              }

                    }

          }

}