Mixed JS

function effect()
{
var x = document.getElementById("para1");
x.style.backgroundColor="yellow";

}
function effectback()
{
var x = document.getElementById("para1");
x.style.backgroundColor="white";
}
function effect2()
{

var x = document.getElementById("para2");
x.style.color = "yellow";

}
function effect2back()
{
var x = document.getElementById("para2");
x.style.color = "black";

}
function idm()
{
var x = document.getElementById("name");
x.style.color = "yellow";
}
function dimb()
{
var x = document.getElementById("name");
x.style.color = "black";
}

function city()
{
var x = document.getElementsByTagName("input");
alert(x.innerHTML);
x.style.color = "yellow";

}
function cityreturn()
{
var x = document.getElementsByTagName("input");
x.style.color = "black";
}

===================================================

document.write("<h1 style='background-color:yellow;color:red'>Welcome to External Java Script..!</h1>");

document.write("</br>");

document.write("thank You");

var str ="Amit Manjhi";

document.write("the string is "+str+"</br>");

var a = 10;

document.write("Int val :"+a);

function validate()

{

alert("Inside validate");

}

function myreturn()

{

return("Hello >>>>>>>>>>>>> I am return value");

}

function sum(a,b)

{

return(a+b);

}

function red()

{

document.bgColor = "red";

}

function green()

{

document.bgColor = "green";

}

function yellow()

{

document.bgColor='yellow';

}

function blue()

{

document.bgColor='blue';

}

===================================================================

function validate()

{ alert("inside 1");

var result = true;

var i = document.getElementsByTagName("input");

if(i[0].value.length==0)

result = false;

return (result);

}

function validateEmail()

{

var result = true;

var e = document.getElementsByName("email")[0].value; // [0] means first email (if there are multiple emails)

//alert(e);

var atindex = e.indexOf('@');

//alert(atindex);

var dotindex = e.lastIndexOf('.');

//alert(dotindex);

if(atindex<1 || dotindex >= e.length-2 || dotindex - atindex <3)

result = false;

return (result);

}

===================================================================

Binary Tree 1

package tree;

public class Node
{
int key;
Node left;
Node right;
}

=======================================================================

package tree;

public class BinaryTree 

{

Node root= null;

Node temp;

public void add(int value) 

{

root = insertRec(root, value);

}

//---------------------------------------

public void inOrderintraverse() 

{

intraverse(root);

}

public void preOrderTraverse() 

{

   pretraverse(root);

}

public void postOrderTraverse() 

{

posttraverse(root);

}

//----------------------------------------

//*****************************************

private Node insertRec(Node root, int value) 

{

if(root == null)

{

Node node = new Node();

node.key = value;

node.left = null;

node.right = null;

root = node;

return node;

}

else

{

if(value < root.key)

root.left = insertRec(root.left, value);

else if(value > root.key)

root.right = insertRec(root.right, value);

}

  

return root;

}

//*************************************

private void intraverse(Node root) 

{

  if(root!= null)

  {    

  intraverse(root.left);

  System.out.println(root.key+" ");

  intraverse(root.right);  

  }

}

//*************************************

private void pretraverse(Node root) 

{

if(root!= null)

  {  

System.out.println(root.key+" ");

pretraverse(root.left);

pretraverse(root.right);  

  }   

}

//*************************************

private void posttraverse(Node root) 

{

if(root!= null)

  {  

posttraverse(root.left);

posttraverse(root.right);

  System.out.println(root.key+" ");

  }   

}

}

======================================================================

package tree;

public class Runner {

public static void main(String[] args) 

{

  BinaryTree tree = new BinaryTree();

  tree.add(50);

  tree.add(30);

  tree.add(20);

  tree.add(35);

  tree.add(55);

  tree.add(52);

  tree.add(60);  

/* System.out.println("InOrder:");

  tree.inOrderintraverse();*/

System.out.println("PreOrder:");

  tree.preOrderTraverse();

  /* System.out.println("PostOrder:");

  tree.postOrderTraverse();

*/

}

}

===================================================================

Stack implementation

package ds.Stack;

public class Runner {

public static void main(String[] args)
{
  Stack stack = new Stack();
  stack.push(10);
  //stack.push(20);
// stack.push(30);

  stack.show();
  int pop1 = stack.pop();
  System.out.println("");
  System.out.println("Popped: "+pop1);
  stack.show();
 
  int peek1 = stack.peek();
  System.out.println("");
  System.out.println("Peeked: "+peek1);
  stack.show();
 
  System.out.println("");
  int size = stack.size();
  System.out.println("Size is:"+size);
 
  System.out.println("");
  stack.isEmpty();
 

}

}

=====================================================================

package ds.Stack;

public class Stack 

{

int[] stack = new int[5];

int  top = 0;

public void push(int i) 

{

if(top==5)

{

System.out.println("Stack is full");

return;

}

else

{

stack[top] = i;

top++;

}

}

public void show() 

{

for(int n :stack)

System.out.print(n+" ");

}

public int pop() 

{

if(top<=0)

{

System.out.println("Stack is Empty");

return 0;

}

else

{

int data;

top--;

data  = stack[top];

stack[top]= 0;

return data;

}

}

public int  peek() 

{

if(top<=0)

{

System.out.println("Stack is Empty");

return 0;

}

else

{

int data;

data  = stack[top -1];

return data;

}

}

public int size() 

{

  return (top);

}

public void  isEmpty() 

{

  if(top<=0)

  System.out.println("Stack is Empty");

  

  else

  System.out.println("Stack is NOT Empty");

  

}

}

========================================================================

Linked list Implementation

package ds.Linked_List;

public class Node
{
   int data;
   Node next;
 
}

========================================================================

package ds.Linked_List;

public class Runner {

public static void main(String[] args) 

{

Linked_List list = new Linked_List();

list.add(10);

list.add(20);

list.add(30);

list.add(40);

list.add(50);

list.show();

System.out.println("After delting 50");

list.delete(50);

list.show();

System.out.println("add at first - 100");

list.addAtFirst(100);

list.show();

}

}

========================================================================

package ds.Linked_List;

public class Linked_List 

{

Node head;

  void add(int data)

  {

  Node node = new Node();

  node.data=data;

  node.next=null;

  if(head == null)

  {

  head = node;

  }

  else

  {

  Node n = head;

  while(n.next != null)

  {

n = n.next;

  }

  n.next = node;

  }

  

  }

  void show()

  {

  Node n = head;

  while(n.next!= null)

  {

  System.out.println(n.data);

  n = n.next;

  }

  System.out.println(n.data);

  }

  void delete(int data)

  {

  Node n = head;

  Node pre = null;

  //For first nod

  if(n.data == data)

  {

  head = n.next;

  }

  //for middle

  else

  {   

  while(n.data!= data)

  {

  pre = n;

  n = n.next;

  }

  pre.next = n.next;

  n.next = null;

  }

  

  }

  void addAtFirst(int data)

  {

 

  Node node = new Node();

  node.data = data;

  node.next = head;

  head = node;

  

  }

}

========================================================================

SelectionSort

package ds.interview.dataStructure.Algo;

import java.util.Arrays;

//Selection Sort : Select min. value and swap with first element
//In Every Lap Smallest element comes at first
public class SelectionSort {

public static void main(String[] args)
{
int min,temp;
int arr[] = {5,8,2,9,1,4,3,7};
for(int i =0;i<arr.length;i++)
{
min = i;
for(int j = i+1;j<arr.length;j++)
{
if(arr[j]<arr[min])
{
min = j;
}
}
temp = arr[i];
arr[i] = arr[min];
arr[min]= temp;
}
System.out.println(Arrays.toString(arr));

}

}

MergeSort

package ds.interview.dataStructure.Algo;
//-----------------------------------------PENDING
import java.util.Arrays;

//https://www.youtube.com/watch?v=TzeBrDU-JaY&list=PL2_aWCzGMAwKedT2KfDMB9YA5DgASZb3U&index=5
//MergeSort
public class MergeSort
{

public static void main(String[] args)
{
  int[] arr = {3,5,8,9,1,6,4,2};
  mergesort(arr);
  System.out.println(Arrays.toString(arr));
}

private static void mergesort(int[] arr)
{
  int length = arr.length;
  if(length<2)
  {
  return;
  }
  else
  {
  int mid = length/2; //-------divide
  int[]left = new int[mid];//-------Left Array
  int[]right = new int[length-mid];//-------Right Array
  //Fill Left Array
  for(int i=0;i<left.length;i++)
  {
  left[i] = arr[i];
  }
  //Fill Right Array
  for(int i=mid+1;i<right.length;i++)
  {
  right[i] = arr[i];
  }
  mergesort(left);
  mergesort(right);
  merge(left,right,arr);
 
 
  }

}

private static void merge(int[] left, int[] right, int[] arr)
{

int i=0; //-----for left
int j=0;//------for right
int k=0;//------for main array
while(i<left.length && j<right.length)
{
if(left[i]<right[j])
{
arr[k] = left[i];
i++;k++;
}
else
    if(left[i]>right[j])
{
arr[k] = right[j];
j++;k++;
}
while(i<left.length)
{
arr[k] = left[i];
i++;k++;
}
while(i<left.length)
{
arr[k] = right[j];
j++;k++;
}
}
}

}

InsertionSort

package ds.interview.dataStructure.Algo;
//Insertion sort
//starts from index 1, and compares itself with previous values to adjust itself
import java.util.Arrays;
public class InsertionSort {

public static void main(String[] args)
{
int temp;
  int arr[] = {4,8,6,2,9,1,7,3};
  for(int i = 1;i<arr.length;i++)
  {
for(int j =i ;j>0 ;j--)
{
if(arr[j]<arr[j-1])
{
temp = arr[j];
arr[j] = arr[j-1];
arr[j-1]= temp;
}
}
  }
  System.out.println(Arrays.toString(arr));
 
}

}

BubbleSort

package ds.interview.dataStructure.Algo;
//Bubble Sort
//In Every Lap Biggest element comes at last

import java.util.Arrays;

public class BubbleSort {

public static void main(String[] args)
{
  int[] arr = {4,7,8,3,2,9,10,1};
  System.out.println("Original: "+Arrays.toString(arr));
  for(int i = 0;i<arr.length-1;i++)
  {
  for(int j=0;j<arr.length-1-i;j++) //"-i" coz. 2nd round me last wale se compare se bache
  {
  if(arr[j]>arr[j+1])
  {
  arr[j]= arr[j]+arr[j+1];
  arr[j+1]= arr[j]-arr[j+1];
  arr[j]=arr[j]-arr[j+1];
  }
  }
  }
 
  //***************Display Sorted elements**********
  System.out.println("Sorted: "+Arrays.toString(arr));
 

}

}

DS : 1 Links

1. Binary Tree 1
2. Stack implementation 
3. Dynamic_Stack_Implementation
4. Linked list Implementation
5. SelectionSort
6. MergeSort 
7. InsertionSort 
8. BubbleSort 
9. 
   

Dynamic_Stack_Implementation

package ds.Dynamic_Stack;

public class Runner {

public static void main(String[] args)
{
  Stack stack = new Stack();
  stack.size();
  stack.push(10);
  stack.size();
  stack.push(10);
  stack.size();
  stack.push(10);
  stack.size();
  stack.push(10);
  stack.size();
  stack.push(10);
  stack.size();
  stack.size();
  stack.push(10);
  stack.size();
  stack.push(10);
  stack.size();
  stack.pop();
  stack.size();
  stack.pop();
  stack.pop();
  stack.size();
  stack.pop();
  stack.size();
  stack.pop();
  stack.pop();
  stack.pop();
  stack.pop();
  stack.pop();
  stack.pop();
  stack.pop();
  stack.size();

}

}

====================================================================

package ds.Dynamic_Stack;

public class Stack 

{

int[] stack = new int[2];

int  top = 0;

int capacity = 2;

public void push(int data) 

{

if(top == capacity)

expand();

stack[top] = data;

top++;

}

private void expand() 

{

System.out.println("Expanding");

int[] newStack = new int[capacity*2];

System.arraycopy(stack, 0, newStack, 0, stack.length);

stack = newStack;

capacity = capacity *2;

}

public void show() 

{

for(int n :stack)

System.out.print(n+" ");

}

public void pop() 

{

int data;

if(top<=0)

{

System.out.println("Stack is Empty");

return;

}

else

{

top--;

data  = stack[top];

stack[top]= 0;

shrink();

}

System.out.println("Popped Data: "+data);

}

private void shrink() 

{

System.out.println("Shrinked");

  int size = stack.length;

  if(size<capacity/2)

  {

  int s1 = capacity/2;

  int[] ShrinkedArray = new int[s1];

  System.arraycopy(stack, 0, ShrinkedArray, 0, stack.length);

  stack = ShrinkedArray;

  }

}

public int  peek() 

{

if(top<=0)

{

System.out.println("Stack is Empty");

return 0;

}

else

{

int data;

data  = stack[top -1];

return data;

}

}

public void size() 

{

  //return (top);

  System.out.println("Size: "+top);

}

public void  isEmpty() 

{

  if(top<=0)

  System.out.println("Stack is Empty");

  

  else

  System.out.println("Stack is NOT Empty");

  

}

}

===========================================================

Star Patterns

1. Star Pattern 1
2. Star Pattern 2
3. Star Pattern 3
4. Star Pattern 4
5. Star Pattern 5
6. Star Pattern 6
7. Star Pattern 7
8. Star Pattern 8
9. Star Pattern 9
10. Star Pattern 10
11. Star Pattern 11
12. Star Pattern 12
13. Star Pattern 13
14. Star Pattern 14
15. Star Pattern 15

StartPattern14

package interview;
/*

 *     *
  *   *
   * *
    *
    *
   * *
  *   *
 *     *

*/
public class StartPattern14 {

public static void main(String[] args)
{
  for(int i =0;i<5;i++)
  {
  for(int j=0;j<5;j++)
  {
  if(i==j || i+j== 5-1)
  {
  System.out.print("*");
  }else
  {
  System.out.print(" ");
  }
 
  }
  System.out.println();
  }

}

}

StarPattern15

package interview;
/*

*****
*   *
*   *
*   *
*****


*/public class StarPattern15 {

public static void main(String[] args)
{
for(int i =0;i<14;i++)
  {
  for(int j=0;j<14;j++)
  {
  if(i==0 || i==14-1 ||j==0 ||j==14-1)
  {
  System.out.print("*");
  }else
  {
  System.out.print(" ");
  }  
  }
  System.out.println();
  }

}

}

StarPattern13

package interview;
/*

 *     *
  *   *
   * *
    *
    *
   * *
  *   *
 *     *

*/

public class StarPattern13 {

public static void main(String[] args)
{
for(int i = 4;i>=1;i--)
  {
  for(int j = 5;j>i;j--)
  {
  System.out.print(" ");
  }
 
  for(int j = 1;j<(i*2);j++)
  {
if(j>1 && j<(i*2)-1)
{
System.out.print(" ");
}else
{
System.out.print("*");
}  
  }
  System.out.println();
  }
//-----
for(int i = 1 ;i<=4;i++)
  {
  for(int j = 4;j>=i;j--)
  {
  System.out.print(" ");
  }
  for(int j = 1;j<(i*2);j++)
  {
if(j>1 && j<(i*2)-1)
{
System.out.print(" ");
}else
{
System.out.print("*");
}  
  }  
  System.out.println();
  }

}

}

StarPattern12

package interview;
/*
    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *
*/

public class StarPattern12 {

public static void main(String[] args)
{

  for(int i = 1 ;i<=5;i++)
  {
  for(int j = 5;j>i;j--)
  {
  System.out.print(" ");
  }
  for(int j = 1;j<=i;j++)
  {
  System.out.print("*");
  }
  //-----------
  for(int j =2;j<=i;j++)
  {
  System.out.print("*");
  }
 
  System.out.println();
  }
//-----------below triangle
  for(int i = 1;i<5;i++)
  {
  for(int j = 0;j<i;j++)
  {
  System.out.print(" ");
  }
  for(int j = 5;j>i;j--)
  {
  System.out.print("*");
  }
  for(int j = 4;j>i;j--)
  {
  System.out.print("*");
  }
  System.out.println();
  }

}

}

StarPattern11

package interview;
/*
     *
    * *
   *   *
  *     *
 *       *
  *     *
   *   *
    * *
     *
*/
public class StarPattern11 {

public static void main(String[] args)
{
  for(int i = 1 ;i<=5;i++)
  {
  for(int j = 4;j>=i;j--)
  {
  System.out.print(" ");
  }
  for(int j = 1;j<(i*2);j++)
  {
if(j>1 && j<(i*2)-1)
{
System.out.print(" ");
}else
{
System.out.print("*");
}  
  }  
  System.out.println();
  }
//-----------below triangle
  for(int i = 4;i>=1;i--)
  {
  for(int j = 5;j>i;j--)
  {
  System.out.print(" ");
  }
 
  for(int j = 1;j<(i*2);j++)
  {
if(j>1 && j<(i*2)-1)
{
System.out.print(" ");
}else
{
System.out.print("*");
}  
  }
  System.out.println();
  }

}

}

StarPattern10

package interview;
/*

*
 *
  *
   *
    *
     *
    *
   *
  *
 *
*

*/
public class StarPattern10 {

public static void main(String[] args)
{
  for(int i = 1 ;i<=6;i++)
  {
  for(int j = 1;j<=i;j++)
  {
  if(i>=2 && j <= i-1)
  {
  System.out.print(" ");
  }  
  else
  {
  System.out.print("*"); 
  }  
  }
  System.out.println();
 
  }
//----------------
  for(int i = 0;i<=5;i++)
  {
  for(int j = 4;j>=i;j--)
  {
  if(j>i && i<5)
  {
  System.out.print(" ");
  }else
  {
  System.out.print("*");
  }  
  }
  System.out.println();
  }

}

}

StarPattern9

package interview;
/*
*******
 *****
  ***
   *
*/
public class StarPattern9 {

public static void main(String[] args)
{
for(int i=0;i<5;i++)
{
for(int j = 0;j<i;j++)
{
System.out.print(" ");
}
for(int j = 4;j>i;j--)
{
System.out.print("*");
}
for(int j=3;j>i;j--)
{
System.out.print("*");
}

System.out.println();

}

}

}

StarPattern8

package interview;
/*

     *
    ***
   *****
  *******
 *********

*/


public class StarPattern8
{

public static void main(String[] args)
{
for(int i = 0;i<5;i++)
{
for(int j = 4;j>i;j--)
System.out.print(" ");
for(int j= 0;j<=i;j++)
System.out.print("*");
for(int j =1;j<=i;j++)
System.out.print("*");

System.out.println();
}


}

}

StarPattern7

package interview;
/*

     *
    * *
   * * *
  * * * *
 * * * * *

 */



public class StarPattern7 {

public static void main(String[] args)
{
for(int i = 1 ;i<=5;i++)
{
for(int j= 4 ;j>=i;j--)
{
System.out.print(" ");
}
for(int k=1;k<=i;k++)
{
System.out.print(" *");
}
System.out.println();
}

}

}

StarPattern6

package interview;
/*
    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *
*/
public class StarPattern6 {

public static void main(String[] args)
{
  for(int i = 0 ;i<5;i++)
  {
for(int j = 4;j>i;j-- )
{
System.out.print(" ");
}
for(int j = 0;j<=i;j++ )
{
System.out.print("*");
}
System.out.println();
  }
  for(int i = 0;i<5;i++)
  {
  for(int j = 0;j<=i;j++ )
{
System.out.print(" ");
}
  for(int j = 4;j>i;j-- )
{
System.out.print("*");
}

System.out.println();
  }
}

}

StarPattern5

package interview;
/*
*****
.****
..***
...**
....*
*/
public class StarPattern5 {

public static void main(String[] args)
{
for(int i = 0 ;i<5;i++)
{
  for(int j = 0;j<i;j++)
  {
  System.out.print(" ");
  }
  for(int j = 5;j>i;j--)
  {
  System.out.print("*");
  }
  System.out.println();
}


}

}

Star Pattern 4

package interview;

/*

 ....*
 ...**
 ..***
 .****
 *****
 
*/
public class StarPattern4
{
public static void main(String[] args)
{
for(int i = 1 ;i<=5;i++)
{
for(int j= 4 ;j>=i;j--)
{
System.out.print(" ");
}
for(int k=1;k<=i;k++)
{
System.out.print("*");
}
System.out.println();
}

}

}

Star Pattern 3

package interview;
/*

*
**
***
****
*****
****** 
*****
****
***
**
*

**/

public class StarPattern3
{

public static void main(String[] args)
{
  for(int i = 1 ;i<6;i++)
  {
  for(int j=0;j<i;j++)
  {
  System.out.print("*");
  }
  System.out.println();
  }
  //-----------
  for(int i = 6 ;i>0;i--)
  {
  for(int j=0;j<i;j++)
  {
  System.out.print("*");
  }
  System.out.println();
  }
 
}

}

Star Pattern 2

package interview;
/*

****** 
*****
****
***
**
*

*/
public class StarPattern2
{
public static void main(String[] args)
{
for(int i =1;i<=6;i++)
{
for(int j=6;j>=i ;j--)
{
System.out.print("*");
}
System.out.println();
}
}

}

Start Pattern 1

package interview;
/*

*
**
***
****
*****

*/
public class StarPattern1 {

public static void main(String[] args)
{
for(int i =1;i<=5;i++)
{
for(int j=1;j<=i ;j++)
{
System.out.print("*");
}
System.out.println();

}
 

}

}

SortMapByValue_TreeMap

package comparator.Emp;

import java.util.*;

public class SortMapByValue_TreeMap
{
public static void main(String[] args)
{
Map <String,String> unsortedmap = new HashMap<>();
unsortedmap.put("one", "one");
unsortedmap.put("tree", "tree");
unsortedmap.put("mount", "mount");
unsortedmap.put("bird", "bird");
unsortedmap.put("house", "house");
System.out.println("***************Unsorted Map**************");
printmap(unsortedmap);
System.out.println("************After sorting Map*************");
        Map<String, String> sortedMap = sortMap(unsortedmap);
        printmap(sortedMap);


}

private static Map<String, String> sortMap(Map<String, String> unsortedmap)
{
// copy unsortedmap to TreeMap
TreeMap <String,String> tm = new TreeMap<>(new SortMapComparator());
for(Map.Entry<String,String> entry : unsortedmap.entrySet())
{
tm.put(entry.getKey(), entry.getValue());
}
return tm;
}

private static void printmap(Map<String, String> unsortedmap)
{
  for(Map.Entry<String,String> entry  : unsortedmap.entrySet())
  {
  System.out.println(entry.getKey()+" : "+entry.getValue());
  }

}

}
=============================================================
package comparator.Emp;

import java.util.Comparator;

public class SortMapComparator implements Comparator <String>
{

@Override
public int compare(String s1 , String s2)
{
    return s1.compareTo(s2);
}


}

==============================================================

Concurrent Modification Exception

package concurrent_Collection;
/*One Thread iterating Collection Object and other thread trying to modify it...
 This leads to Concurrent Modification Exception
java.util.ConcurrentModificationException*/

import java.util.*;

public class ConcurrentModificationException extends Thread
{
static ArrayList list = new ArrayList();
public void run()
{
try
{
  Thread.sleep(700);
}
catch(Exception e)
{
System.out.println(e.toString());
}
System.out.println("Child Thread adding ---> 10");
list.add(10);
}

public static void main(String[] args) throws Exception
{
  list.add(59);
  list.add(788);
  list.add(45);
  list.add(88);
  ConcurrentModificationException thread = new ConcurrentModificationException();
  thread.start();
  Iterator itr = list.iterator();
  while(itr.hasNext())
  {
  System.out.println(itr.next());
  Thread.sleep(500);
  }

}

}

Sort HashMap according to Value

package test;

import java.util.*;

//map ---list--sort--map(display)
public class SortMap_Value
{
public static void main(String[] args)
{
Map<String,Integer> map = new HashMap<>();
map.put("A", 78);
map.put("B", 55);
map.put("C", 807);
map.put("D", 34);
map.put("E", 89);
map.put("F", 700);

//List<Map.Entry<String, Integer>> list = new LinkedList<>(map.entrySet());
List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
Collections.sort(list, new MyComparator2());

Map<String,Integer> map2 = new LinkedHashMap<>();
for(Map.Entry<String,Integer> entry : list)
{
map2.put(entry.getKey(), entry.getValue());
}
for(Map.Entry<String,Integer> entry : map2.entrySet())
{
System.out.println(entry.getKey()+" : "+entry.getValue());
}


}

}
========================================
package test;

import java.util.Comparator;import java.util.Map;
import java.util.Map.Entry;


public class MyComparator2 implements Comparator<Map.Entry<String,Integer>>
{

@Override
public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2)
{

//return o1.getValue().compareTo(o2.getValue());
return o2.getValue().compareTo(o1.getValue());
}

}

=========================================

Collection_Links

1. Sort HashMap according to Value
2. Ways to Iterate HashMap
3. COMPARATOR::: Sort Employee Object using employee id
4. COMPARATOR:: Sort simple ArrayList of STRING & INTEGER
5. Comparable:::::Sorting Book Object according to Book ID
6. Comparable:::::Sort an object using comparable
7. Comparable :::::Sort Employee OBJECT according to Names
8. SortMapByValue_TreeMap
9. Sort Map According to its Value (Used Comparator ,List &  LinkedHashMap)
10. Sort Map by Values
11. Sort Map using comparator
12. Sort Map by Key
13. Sort map Using KEY