HashMap

Mechanism

mechanism in HashMap to store this key value pair. HashMap has an inner class Entry
static class Entry<K ,V> implements Map.Entry<K ,V>
{
final K key;
V value;
Entry<K ,V> next;
final int hash;
…//More code goes here
}

What put() method actually does

1)    First of all, key object is checked for null. If key is null, value is stored in table[0] position. Because hash code for null is always 0.
2)    Then on next step, a hash value is calculated using key’s hash code by calling its hashCode() method. JDK designers well assumed that there might be some poorly written hashCode() functions that can return very high or low hash code value. To solve this issue, they introduced another hash() function, and passed the object’s hash code to this hash() function to bring hash value in range of array index size.
3)    Now indexFor(hash, table.length) function is called to calculate exact index position for storing the Entry object.
4)    Entry objects are stored in LinkedList form. HashMap checks whether there is already an entry?? If there is no entry already present, Entry object is stored in this location.
5)    If there is already an object sitting on calculated index, its next attribute is checked. If it is null, and current Entry object becomes next node in LinkedList. If next variable is not null, procedure is followed until next is evaluated as null.

What if we add the another value object with same key as entered before. Logically, it should replace the old value. How it is done? Well, after determining the index position of Entry object, while iterating over LinkedList on calculated index, HashMap calls equals method on key object for each Entry object. All these Entry objects in LinkedList will have similar hash code but equals() method will test for true equality. If key.equals(k) will be true then both keys are treated as same key object. This will cause the replacing of value object inside Entry object only.
In this way, HashMap ensure the uniqueness of keys.

How get() methods works internally
Answer we already should know that the way key uniqueness is determined in put() method , same logic is applied in get() method also. The moment HashMap identify exact match for the key object passed as argument, it simply returns the value object stored in current Entry object.
If no match is found, get() method returns null.
Above code is same as put() method till if (e.hash == hash && ((k = e.key) == key || key.equals(k))), after this simply value object is returned.

Key Notes
1.    Data structure to store Entry objects is an array named table of type Entry.
2.    A particular index location in array is referred as bucket, because it can hold the first element of a LinkedList of Entry objects.
3.    Key object’s hashCode() is required to calculate the index location of Entry object.
4.    Key object’s equals() method is used to maintain uniqueness of Keys in map.
5.    Value object’s hashCode() and equals() method are not used in HashMap’s get() and put() methods.
6.    Hash code for null keys is always zero, and such Entry object is always stored in zero index in Entry[].

How will you measure the performance of HashMap?

An instance of HashMap has two parameters that affect its performance: initial capacity and load factor.

The capacity is the number of buckets in the hash table( HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls.), and the initial capacity is simply the capacity at the time the hash table is created.

The load factor is a measure of how full the hash table is allowed to get before its capacity is automatically increased. When the number of entries in the hash table exceeds the product of the load factor and the current capacity, the hash table is rehashed (that is, internal data structures are rebuilt) so that the hash table has approximately twice the number of buckets.
In HashMap class, the default value of load factor is (.75) .

Struts

Find word in a file

br = new BufferedReader(new FileReader(filePath));
        try {
            while((line = br.readLine()) != null)
            {
                String[] words = line.split(" ");

                for (String word : words) {
                  if (word.equals(inputSearch)) {
                    count++;
                  }
              }
          }
      }

OR

br = new BufferedReader(new FileReader(filePath));
        try {
            while((line = br.readLine()) != null)
            {
                  if (line.contains(inputSearch)) {
                    count++;
                  }
             }
         }
    }

HashCode() and equals()

hashCode() method is used to get a unique integer for given object. This integer is used for determining the bucket location, when this object needs to be stored in some HashTable like data structure. By default, Object’s hashCode() method returns and integer representation of memory address where object is stored.
equals() method, as name suggest, is used to simply verify the equality of two objects. Default implementation simply check the object references of two objects to verify their equality.

1. Always use same attributes of an object to generate hashCode() and equals() both. As in our case, we have used employee id.
2. equals() must be consistent (if the objects are not modified, then it must keep returning the same value).
3. Whenever a.equals(b), then a.hashCode() must be same as b.hashCode().
4. If two objects have the same hashcode, they may or may not be equal.
5. If you override one, then you should override the other.

The “==” operator
In Java, when the “==” operator is used to compare 2 objects, it checks to see if the objects refer to the same place in memory. In other words, it checks to see if the 2 object names are basically references to the same memory location. A very simple example will help clarify this:

String obj1 = new String("xyz");
String obj2 = new String("xyz");

obj1==obj2 is FALSE

String obj1 = new String("xyz");
// now obj2 and obj1 reference the same place in memory
String obj2 = obj1;

obj1==obj2 is TRUE

The equals() method
equals method is actually meant to compare the contents of 2 objects, and not their location in memory.

String obj1 = new String("xyz");
String obj2 = new String("xyz");

obj1.equals(obj2) is TRUE

by default equals() will behave the same as the “==” operator and compare object locations. But, when overriding the equals() method, you should compare the values of the object instead.
The Java String class actually overrides the default equals() implementation in the Object class – and it overrides the method so that it checks only the values of the strings, not their locations in memory. This means that if you call the equals() method to compare 2 String objects, then as long as the actual sequence of characters is equal, both objects are considered equal.

Autoboxing

Autoboxing and unboxing is introduced in Java 1.5 to automatically convert primitive type into boxed primitive( Object or Wrapper class). autoboxing allows you to use primitive and object type interchangeably in Java on many places like assignment, method invocation etc.

ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(1); //autoboxing – primitive to object
intList.add(2); //autoboxing

combine multiple csv files into one excel workbook as different sheets using java

public class csvxls{
    public static void main(String[]args){
    try{
        File folder = new File("F:/csvfiles/");
        File[] listOfFiles = folder.listFiles();
        HSSFWorkbook workbook=new HSSFWorkbook();

        for (File file : listOfFiles) {
            if (file.isFile()) {
                String thisline;
                ArrayList<String> al = null;
                ArrayList<ArrayList<String>> arlist = new ArrayList<ArrayList<String>>();

                HSSFSheet sheet =  workbook.createSheet(file.getName());  
                FileInputStream fis = new FileInputStream(file);
                BufferedReader br = new BufferedReader(new InputStreamReader(fis));

                while ((thisline = br.readLine()) != null) {
                    al = new ArrayList<String>();
                    String strar[] = thisline.split(",");

                    for (int j = 0; j < strar.length; j++) { 
                        for (int k = 0; k < arlist.size(); k++) {
                            ArrayList<String> ardata = (ArrayList<String>) arlist.get(k);
                            HSSFRow row = sheet.createRow((short) k);

                            for (int p = 0; p < ardata.size(); p++) {
                                HSSFCell cell = row.createCell((short) p);
                                cell.setCellValue(ardata.get(p).toString());
                            }
                        }
                        al.add(strar[j]);
                    } 
                  arlist.add(al);
                }

                fis.close();  
                FileOutputStream fileOut = new FileOutputStream("F://NewWBFile.xls");
                workbook.write(fileOut);
                fileOut.flush();
                fileOut.close();
                br.close();
            }
        }
    System.out.println("Your excel file has been generated!");
    } catch ( Exception ex ) {
        System.out.println(ex);
       }
    }
}

Synchronized Threading

import java.util.*;
import java.lang.*;
import java.io.*;
    
class Table{   
    void printTable(int n){  
        synchronized(this){ 
           System.out.println(n);  
        }  
    }  
}
      
class MyThread1 extends Thread {  
    Table t;  
    
    MyThread1(Table t){  
        this.t=t;  
    }  
    
    public void run(){  
        t.printTable(5);  
    }      
}  

class MyThread2 extends Thread{  
    Table t;  
    
    MyThread2(Table t){  
        this.t=t;  
    }  
    
    public void run(){  
        t.printTable(100);  
    }  
}  
      
class TestSynchronizedBlock1{  
    public static void main(String args[]){  
        Table obj = new Table();
        MyThread1 t1=new MyThread1(obj);  
        MyThread2 t2=new MyThread2(obj);  
        t1.start();  
        t2.start();  
    }  
}

Threads

class MultithreadingDemo implements Runnable{  
  public void run(){  
    System.out.println("My thread is in running state.");  
  }   
  public static void main(String args[]){  
     MultithreadingDemo obj=new MultithreadingDemo();  
     Thread tobj =new Thread(obj);  
     tobj.start();  
 }  
}

class MultithreadingDemo extends Thread{  
  public void run(){  
    System.out.println("My thread is in running state.");  
  }   
  public static void main(String args[]){  
     MultithreadingDemo obj=new MultithreadingDemo();   
     obj.start();  
  }  
}

String vs StringBuilder vs StringBuffer

String
String is immutable  ( once created can not be changed )object  . The object created as a String is stored in the  Constant String Pool  . They are thread safe.
StringBuffer

StringBuffer is mutable means one can change the value of the object . Object created through StringBuffer is stored in the heap. Each method in StringBuffer is synchronized that is StringBuffer is thread safe

StringBuilder

StringBuilder is same as the StringBuffer , that is it stores the object in heap and it can also be modified . StringBuilder is also not thread safe.

Collections in Java

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.