Sort HashMap By Keys

                   Sorting HashMap  by Keys  using TreeMap and Comparator

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

import com.kanth.bo.Employee;

public class HashMapSortKeys {

    public static void main(String[] args) {

        Map<String, Employee> unsortedMap = getEmpData();

        Map<String, Employee> treeMap = new TreeMap<String, Employee>(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return Integer.parseInt(s1) > Integer.parseInt(s2) ? 1 : -1;
            }
        });

        unsortedMap.forEach((k, v) -> {
            treeMap.put(k, v);
        });

        System.out.println("after sorting " + treeMap.size());
        treeMap.forEach((k, v) -> {
            System.out.println("key is " + k + "Value is " + v);
        });
    }

    public static Map<String, Employee> getEmpData() {
        String proj1[] = { "Singtel", "Ericson", "STC", "TM" };
        String proj2[] = { "Singtel", "Cisco", "STC", "TM" };
        String proj3[] = { "STC", "TM" };
        Map<String, Employee> empData = new HashMap<>();
        empData.put("1234", new Employee("Ramakanth", 31000d, "SMP", 27, proj1));
        empData.put("112", new Employee("Sanjay", 40000d, "IOT", 27, proj1));
        empData.put("578", new Employee("Anil", 50000d, "SMP", 28, proj3));
        empData.put("889", new Employee("Raju", 30000d, "SMP", 27, proj2));
        empData.put("762", new Employee("Vijay", 20000d, "IOT", 32, proj1));
        empData.put("687", new Employee("Eswar", 27000d, "SMP", 30, proj2));
        empData.put("579", new Employee("Satish", 21000d, "ADP", 26, proj3));

        return empData;
    }

}


class Employee {

    private String name;
    private Double salary;
    private String Dept;
    private Integer age;
    private String[] projects;
//getters and setters
}

Read More

Sort HashMap By Values

                  Sort the HashMap by Values using comperator and Entry Object



import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import java.util.Set;

import com.kanth.bo.Employee;

public class HashMapSortByValues {

    public static void main(String[] args) {

        Map<String, Employee> unsortedMap = getEmpData();

        Set<Entry<String, Employee>> dataset = unsortedMap.entrySet();
        List<Entry<String, Employee>> mylist = new ArrayList<>(dataset);

        //Comparator for sorting by salary for Employee Object
        Comparator<Entry<String, Employee>> myvalucomp = new Comparator<Entry<String, Employee>>() {

            @Override
            public int compare(Entry<String, Employee> o1, Entry<String, Employee> o2) {
                return o1.getValue().getSalary() < o2.getValue().getSalary() ? 1 : -1;
            }

        };

        //sorting based on comparator
        Collections.sort(mylist, myvalucomp);

       
        //LinkedHashMap -- as it maintains the order
        Map<String, Employee> sortedMap = new LinkedHashMap<>();
        sortedMap = mylist.stream()
                .collect(Collectors.toMap(Entry::getKey, Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

        // sorted by values

        sortedMap.forEach((k, v) -> {
            System.out.println("The key is " + k + " values " + v);
        });

    }

    public static Map<String, Employee> getEmpData() {
        String proj1[] = { "Singtel", "Ericson", "STC", "TM" };
        String proj2[] = { "Singtel", "Cisco", "STC", "TM" };
        String proj3[] = { "STC", "TM" };
        Map<String, Employee> empData = new HashMap<>();
        empData.put("1234", new Employee("Ramakanth", 31000d, "SMP", 27, proj1));
        empData.put("112", new Employee("Sanjay", 40000d, "IOT", 27, proj1));
        empData.put("578", new Employee("Anil", 50000d, "SMP", 28, proj3));
        empData.put("889", new Employee("Raju", 30000d, "SMP", 27, proj2));
        empData.put("762", new Employee("Vijay", 20000d, "IOT", 32, proj1));
        empData.put("687", new Employee("Eswar", 27000d, "SMP", 30, proj2));
        empData.put("579", new Employee("Satish", 21000d, "ADP", 26, proj3));

        return empData;
    }
}

class Employee {

    private String name;
    private Double salary;
    private String Dept;
    private Integer age;
    private String[] projects;
//getters and setters

}

Read More

Stream API

      Java 8 Stream API  Basic Examples.

        Let us understand the few ways  where we can use java 8 streams to solve the problems.

github link: https://github.com/RamakanthB/Java8Lamda-Streams

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class StreamBasics {

    public static void main(String[] args) {

        List<Employee> emplist = getAllEmpData();
       
        System.out.println("*********** Print All Employees Details ***********");
       
        emplist.stream().forEach(System.out::println);

        System.out.println("*********** Only Name of Employees  ***********");
       
        emplist.stream().map(s -> s.getName()).forEach(System.out::println);

        System.out.println("*********** Only DEV Dept Employees ***********");

        emplist.stream().filter(s -> "DEV".equals(s.getDept())).map(s ->
        s.getName()).forEach(System.out::println);

                                             
        System.out.println("***** Only DEV Dept ans store in new List of Beans*****");

        List<Employee> devemplist = emplist.stream().filter(s -> "DEV".equals(s.getDept()))
                .collect(Collectors.toList());
        devemplist.stream().forEach(System.out::println);

        System.out.println("*********** Only STC Project ***********");

        long count = emplist.stream().flatMap(s ->
                             Arrays.stream(s.getProjects())).peek(System.out::println)
                             .filter(s -> s.equals("STC")).count();
        System.out.println("People who are assigned with STC " + count);

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

        Optional<Employee> higestSal = emplist.stream().reduce((s1, s2) -> s1.getSalary() >
        s2.getSalary() ? s1 : s2);
        higestSal.ifPresent(System.out::println);

    }
   
    public static List<Employee> getAllEmpData() {

        List<Employee> emplist = Arrays.asList(
                new Employee("Ramakanth", 20000d, "DEV", 27, new String[] { "STC", "TMOB", "GPAYROLL" }),
                new Employee("Sanjay", 10000d, "TES", 27, new String[] { "IBM", "ACC" }),
                new Employee("Wasim", 17000d, "DEV", 27, new String[] { "STC", "TMOB" }),
                new Employee("Umakanth", 8000d, "AID", 25, new String[] { "NXP" }),
                new Employee("Pavan", 30000d, "DEV", 27, new String[] { "STC", "CGI" }),
                new Employee("Vijay", 10000d, "TES", 27, new String[] {  "TMOB", "GPAYROLL" }),
                new Employee("Debasis", 17000d, "DEV", 27, new String[] {"GPAYROLL" }),
                new Employee("Siva", 8000d, "AID", 27, new String[] { "STC", "TMOB" }),
                new Employee("Hema", 40000d, "DEV", 32, new String[] { "STC", "TMOB", "GPAYROLL" }),
                new Employee("Deepak", 22000d, "TES", 31, new String[] { "TMOB", "GPAYROLL" }));
        return emplist;
    }
}

class Employee {

    private String name;
    private Double salary;
    private String Dept;
    private Integer age;
    private String[] projects;

    public String getName() {
        return name;
    }

    public String[] getProjects() {
        return projects;
    }

    public void setProjects(String[] projects) {
        this.projects = projects;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public String getDept() {
        return Dept;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", salary=" + salary + ", Dept=" + Dept + ", age=" + age + ", projects="
                + Arrays.toString(projects) + "]";
    }

    public Employee(String name, Double salary, String dept, Integer age, String[] projects) {
        super();
        this.name = name;
        this.salary = salary;
        Dept = dept;
        this.age = age;
        this.projects = projects;
    }

    public void setDept(String dept) {
        Dept = dept;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }


}

Read More

Joining the strings in java 8

 Everyone will experience the scenario where we need to join the strings in java .

These are the few ways we can do String concatenation in java 8.

 Lets say we have 5 strings we want to make it 1 string with ',' separator .

   String finalval = String.join(",", "First", "Second", "Third", "Forth");

        

         output : First,Second,Third,Forth

 In Case of array of String then,

   String arry[] = { "Mango", "Apple", "Papaya" };

    String finalval = String.join("-", arry);  

        

         output : Mango-Apple-Papaya

    

Lets say we want to append string to create IN params for SQL Query then,

        import java.util.StringJoiner;

         StringJoiner sj = new StringJoiner("','", "('", "')");

          sj.setEmptyValue("It is empty");   

          System.out.println(sj.toString());  //prints 'It is empty'  as nothing is there to join  

          sj.add("nike").add("Reebok").add("Puma").add("LV").add("Gucci");

          System.out.println(sj.toString());

      output:('nike','Reebok','Puma','LV','Gucci')

            

    We can merge the two StringJoiners, 

           StringJoiner sj2 = new StringJoiner(",");

           sj2.add("Fossil");

          sj.merge(sj2);

          System.out.println(sj.toString());

output:('nike','Reebok','Puma','LV','Gucci','Fossil')

Read More

Singleton Design Pattern in Java

• singleton is a way to restrict only one object per a class  

    There are multiple ways of creating a singleton object 

 1) eager initialized singleton 

      public class MySingelton1 {

private final static  MySingelton1 myobj =new MySingelton1();

private MySingelton1() {

System.out.println("new instance created MySingelton1");

}

public static MySingelton1 getMyobj() {

return myobj;

}

}

This class object is created  only once during the loading time itself 

2) lazy initialized singleton

  

   public class MySingelton2 {

private  static volatile MySingelton2 myobj=null;

private MySingelton2() {

System.out.println("new instance created MySingelton2");

}

public static MySingelton2 getMyobj() {

 if (myobj == null) {
synchronized (MySingelton2.class)
{
if (myobj == null) {
myobj = new MySingelton2();
}
}
}

return myobj;

}

}

 This class object is cretaed only once when you called the getMyobj() method for the first time.

Read More

Convert from List to IN params for SQL

         Convert from List to IN params for SQL 


public static <T> String getWithINParam(List<T> paraList) {
try {
if (null != paraList)
return paraList.stream().map(s -> new                                                                                                      StringBuilder("'").append(s).append("'")).collect(joining(","));                                               
} catch (Exception e) {
LOG.error("Error in setting IN para for SQL  ", e);

}
return "''";
}

Read More