Java 80:20

Thursday, February 7, 2019

Sort Map According to its Value (Used Comparator ,List & LinkedHashMap)

package sort_Map_byValue;
import java.util.*;
//Program to sort Map value
//Map--->copy entry to List--->sort List using comparator-->copy to new Map-->display
public class SortMapbyValue
{
public static void main(String[] args)
{
//Map create
Map <String,Integer> map = new HashMap<>();
map.put("A", 65);
map.put("B", 60);
map.put("C", 75);
map.put("D", 97);
map.put("E", 90);
map.put("F", 85);
map.put("G", 81);
map.put("H", 75);
//copy to List
//create linked List & pass entryset--> as it maintains the insertion order)
List<Map.Entry<String,Integer>> list = new LinkedList<>(map.entrySet());
//Sort List
//MyComparator mc = new MyComparator();
Collections.sort(list, new MyComparator());
//copy the sorted to new LinkedHashMap (temp)
Map<String,Integer> sortedMap = new LinkedHashMap<>();
for(Map.Entry<String, Integer> entry : list)
{
sortedMap.put(entry.getKey(), entry.getValue());
}
//Dispaly the Sorted Map (Soerted According to Value)
for(Map.Entry<String,Integer> entry : sortedMap.entrySet())
{
System.out.println(entry.getKey() +" : "+entry.getValue());
}
}
}
=================================================
package sort_Map_byValue;
import java.util.Comparator;
import java.util.Map;
public class MyComparator implements Comparator<Map.Entry<String, Integer>>
{
@Override
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2)
{
return (o1.getValue()).compareTo(o2.getValue());
}
}
==================================================

Sort Map by Values

package test;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SortMapbyValues
{
public static boolean ASC = true;
public static boolean DESC = false;

public static void main(String[] args)
{
Map<String, Integer> unsortMap = new HashMap<>();
unsortMap.put("B", 55);
unsortMap.put("A", 80);
unsortMap.put("D", 20);
unsortMap.put("C", 70);

System.out.println("Before sorting......");
printMap(unsortMap);

System.out.println("After sorting ascending order......");
Map<String, Integer> sortedMapAsc = sortByComparator(unsortMap, ASC);
printMap(sortedMapAsc);

System.out.println("After sorting descindeng order......");
Map<String, Integer> sortedMapDesc = sortByComparator(unsortMap, DESC);
printMap(sortedMapDesc);

}

private static Map<String, Integer> sortByComparator(Map<String, Integer> unsortMap, final boolean order)
{

List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(unsortMap.entrySet());

// Sorting the list based on values
Collections.sort(list, new Comparator<Entry<String, Integer>>()
{
public int compare(Entry<String, Integer> o1,
Entry<String, Integer> o2)
{
if (order)
{
return o1.getValue().compareTo(o2.getValue());
}
else
{
return o2.getValue().compareTo(o1.getValue());

}
}
});

// Maintaining insertion order with the help of LinkedList
Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
for (Entry<String, Integer> entry : list)
{
sortedMap.put(entry.getKey(), entry.getValue());
}

return sortedMap;
}

public static void printMap(Map<String, Integer> map)
{
for (Entry<String, Integer> entry : map.entrySet())
{
System.out.println("Key : " + entry.getKey() + " Value : "+ entry.getValue());
}
}
}

Sort Map using comparator

package test;

import java.util.*;

public class SortMap_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 test;

import java.util.Comparator;

public class SortMapComparator implements Comparator <String>

{

@Override

public int compare(String s1 , String s2)

{

return s1.compareTo(s2);

}

Wednesday, February 6, 2019

Sort Map by Key

package interview;
import java.util.*;
//Sort HashMap according to key
//Map -->Map(to keeep sorted items)---->TreeMap---(default comparable)-->Sorted
public class SortHashMap_1 {

public static void main(String[] args)
{
Map <String, String> map = new HashMap<>();
map.put("orange", "orange");
map.put("guava", "guava");
map.put("mango", "mango");
map.put("pineapple", "pineapple");
map.put("banana", "banana");
map.put("grapes", "grapes");
System.out.println(map);
//TreeMap is a class which follows some sorting order for elements
Map <String,String> map2 = new TreeMap(map);
//Now display
System.out.println("*********************Sorted *************************");
for(Map.Entry<String,String> entry : map2.entrySet())
{

System.out.println(entry.getKey() +" : "+entry.getValue());
}

}

}

Sort Map using Key

package test;

import java.util.Map;
import java.util.TreeMap;

public class Sorting_TreeMap_DNSO {

public static void main(String[] args)
{
Map <String,String> map = new TreeMap<>(); //Sorting : Default Natural(Keys)
map.put("orange", "orange");
map.put("guava", "guava");
map.put("mango", "mango");
map.put("pineapple", "pineapple");
map.put("banana", "banana");
System.out.println(map);

}

}

Program to Reverse an array

Solution 1 - Revere array in Place (not recommended)

package interview;

import java.util.Arrays;
import java.util.List;

public class Reverse_Array {

public static void main(String[] args)
{
int[] arr = {1,2,3,4,5,6,7,8,9,10};
System.out.println("Before : "+Arrays.toString(arr));
/*List<int[]> l = Arrays.asList(arr);
System.out.println(l.toArray());*/
for(int i =0 , j = arr.length-1; i<j; i++,j--)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

}
System.out.println("After : "+Arrays.toString(arr));

}

}

Solution 2 - Revere array in Place (for interview)

package phase_one;

import java.util.Arrays;

public class ReverseArray_Using_ForLoop

{

public static void main(String[] args)

{

int[] arr = new int[] {7,84,3,9,11,6};

System.out.println("Before: "+Arrays.toString(arr));

for(int i= 0;i<arr.length/2;i++)

{

int temp = arr[i];

arr[i] = arr[arr.length-i-1];

arr[arr.length-i-1] = temp;

}

System.out.println("After: "+Arrays.toString(arr));

}

Solution 3 - Revere array Using Collections

package phase_one;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

public class ReverseArray_Using_ArrayList {

public static void main(String[] args)

{

String[] arr = {"apple", "tree", "play"};

System.out.println("before: " + Arrays.toString(arr) );

List<String> listOfProducts = Arrays.asList(arr);

Collections.reverse(listOfProducts);

String[] reversed = listOfProducts.toArray(arr);

System.out.println("after: " + Arrays.toString(reversed) );

System.out.println("**************************************");

Integer[] arr2 = new Integer[] {1,2,3,4,5};

// List<Integer> list = Arrays.asList(arr2);

System.out.println(Arrays.toString(arr2));

List<Integer> li = Arrays.asList(arr2); //--array to List

Collections.reverse(li); // reverse List

Integer[] rev = li.toArray(arr2);

System.out.println(Arrays.toString(rev));

}