image source Google Search

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) Duplicate count in ArrayList?


R)


import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


public class CoutArrayListDuplicate {


/**

* @param args
*/
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("aaa");
list.add("a");
list.add("a");
Set<String> unique = new HashSet<String>(list);
for(String key:unique)
{
System.out.println(key +":"+Collections.frequency(list, key));
}
}

}

O/P
aaa:2
a:2
bbb:1

Q) Delete Duplicates in ArrayList ?



R)

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;


public class DeleteDuplicateArrayList {

          /**
           * @param args
           */
          public static void main(String[] args) {
                   ArrayList al = new ArrayList();
                   al.add("A");
                   al.add("A");
                   al.add("B");
                   al.add("B");
                   al.add("C");
                   al.add("D");
                   HashSet hs = new HashSet(al);
                   ArrayList al1 = new ArrayList(hs);
                   Collections.sort(al1);
                   for(Object item:al1){
                             System.out.println(" Iten "+item);
                   }

          }

}

O/P
 Iten A
 Iten B
 Iten C
 Iten D

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("Chandra");
                    listA.add("Sekhar");
                    listA.add("Madhavi");
                    listA.add("Charan");

                    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);
                                        }
                              }
                    }
          }
}








Post a Comment

 
Top