Spring DI with Object Using Setter Injection

We will see below how to inject dependency object through the Setter Injection.

package com.bk.spring.test;

public class StudentBean {

    private int id;
    private String name;
    private String emailId;
    private CourseBean courseBean;

    public int getId() {
        return id;
    }


    public void setId(int id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }


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


    public String getEmailId() {
        return emailId;
    }


    public void setEmailId(String emailId) {
        this.emailId = emailId;
    }


    public CourseBean getCourseBean() {
        return courseBean;
    }


    public void setCourseBean(CourseBean courseBean) {
        this.courseBean = courseBean;
    }


    public void getStudentDetails() {
        System.out.println("Id is " + this.id + " \n name is " + name
                + " \n email id is " + emailId +  "\n" + courseBean.getCourseDetails());
    }

}

package com.bk.spring.test;

public class CourseBean {

    private String name;
    private String duration;
    private Double fee;

    public String getName() {
        return name;
    }

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

    public String getDuration() {
        return duration;
    }

    public void setDuration(String duration) {
        this.duration = duration;
    }

    public Double getFee() {
        return fee;
    }

    public void setFee(Double fee) {
        this.fee = fee;
    }
       
    public String getCourseDetails(){
        return "Course " + name + " has " + duration + " duration with fee " + fee;
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean name="student" class="com.bk.spring.test.StudentBean">
        <property name="id" value="1"></property>
        <property name="name" value="Krishna"></property>
        <property name="emailId" value="Krishna@abc.com"></property>
        <property name="courseBean" ref="courseBean"></property>
    </bean>
    <bean name="courseBean" class="com.bk.spring.test.CourseBean">
        <property name="name" value="Java"></property>
        <property name="duration" value="90Days"></property>
        <property name="fee" value="2018"></property>
       </bean>
   </beans>


package com.bk.spring.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class SpringConDITest {

    public static void main(String a[]) {

        Resource res = new ClassPathResource("applicationContext.xml");
        BeanFactory factory = new XmlBeanFactory(res);
        StudentBean bean = (StudentBean) factory.getBean("student");
        bean.getStudentDetails();
       
    }

}
Output:

Id is 1
 name is Krishna
 email id is Krishna@abc.com
Course Java has 90Days duration with fee 2018.0
 

Spring DI with Object Using CI

We will see below how to inject dependency object through the Constructor Injection.

package com.bk.spring.test;

public class CourseBean {

    private String name;
    private String duration;
    private Double fee;

   public CourseBean(String name, String duration, Double fee){
        this.name = name;
        this.duration = duration;
        this.fee = fee;
    }
   
    public String getCourseDetails(){
        return "Course " + name + " has " + duration + " duration with fee " + fee;
    }

}


package com.bk.spring.test;

public class StudentBean {

    private int id;
    private String name;
    private String emailId;
    private CourseBean courseBean;
    private double fee;

    StudentBean() {
        System.out.println("default constructor");
    }

    StudentBean(String name) {
        this.name = name;
    }
   
    StudentBean(int id) {
        this.id = id;
    }

    StudentBean(int id, String name, String emailId, CourseBean courseBean, double fee) {
        this.id = id;
        this.name = name;
        this.emailId = emailId;
        this.courseBean = courseBean;
        this.fee = fee;
    }

    public void getStudentDetails() {
        System.out.println("Id is " + this.id + " \n name is " + name
                + " \n email id is " + emailId +  "\n" + courseBean.getCourseDetails());
    }

}


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean name="student" class="com.bk.spring.test.StudentBean">
        <constructor-arg value="001" />
        <constructor-arg value="krishna" />
        <constructor-arg value="Krishna@abc.com" />
        <constructor-arg>
        <ref bean="courseBean"/>
        </constructor-arg>
        <constructor-arg value="2018" />
    </bean>
    <bean name="courseBean" class="com.bk.spring.test.CourseBean">
        <constructor-arg value="Java"/>
        <constructor-arg value="90 Days"/>
        <constructor-arg value="2018"/>
    </bean>
  </beans>

package com.bk.spring.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class SpringConDITest {

    public static void main(String a[]) {

        Resource res = new ClassPathResource("applicationContext.xml");
        BeanFactory factory = new XmlBeanFactory(res);
        StudentBean bean = (StudentBean) factory.getBean("student");
        bean.getStudentDetails();
          }

}

Output :
Id is 1
 name is krishna
 email id is Krishna@abc.com
Course Java has 90Days duration with fee 2018.0

Spring CI with Map

We can inject the map values by constructor in spring frame work. We can inject the map as follows.

package com.bk.spring.test;

import java.util.Map;

public class TestBean {

    private String id;
    private String question;
    private Map<String, String> answers;

    public TestBean(String id, String question, Map<String, String> answers) {
        this.id = id;
        this.question = question;
        this.answers = answers;
    }

    public void displayQandA() {
        System.out.println("Question id is");
        System.out.println(id);
        System.out.println("Question is");
        System.out.println(question);
        System.out.println("Answer is ");
        System.out.println(answers);
    }

}


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
        <bean name="testBean" class="com.bk.spring.test.TestBean">
        <constructor-arg value="00001" />
        <constructor-arg value="What is Spring?"></constructor-arg>
        <constructor-arg>
            <map>
                <entry key="Spring is Enterprise application dev framework" value="Krishna"></entry>
                <entry key="Spring is open source framework" value="Chandu"></entry>
            </map>
        </constructor-arg>
    </bean>
</beans>

package com.bk.spring.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class SpringConDITest {

    public static void main(String a[]) {

        Resource res = new ClassPathResource("applicationContext.xml");
        BeanFactory factory = new XmlBeanFactory(res);
               
        TestBean testBean = (TestBean)factory.getBean("testBean");
        testBean.displayQandA();

    }

}


Output:

Question id is
00001
Question is
What is Spring?
Answer is
{Spring is Enterprise application dev framework=Krishna, Spring is open source framework=Chandu}

Spring CI with collections

We can inject the collection values by constructor in spring frame work. We can inject the list as follows.

package com.bk.spring.test;

import java.util.List;

public class EmployeeBean {

    private String id;
    private String name;
    private List<String> projects;
   
    public EmployeeBean(String id, String name, List<String> projects){
        this.id = id;
        this.name = name;
        this.projects = projects;
    }
   
    public void displayEmplyeeDetails(){
        System.out.println("employee details are " + id + " ");
        System.out.println("id is " + id);
        System.out.println("name is " + name);
        System.out.println("projects are " );
        for (String string : projects) {
            System.out.println(string);
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
       <bean name="employeeBean" class="com.bk.spring.test.EmployeeBean">
        <constructor-arg value="0000001" />
        <constructor-arg value="Krishna" />
        <constructor-arg>
            <list>
                <value>Java Project</value>
                <value>J2EE Project</value>
                <value>Spring Project</value>
            </list>
        </constructor-arg>
    </bean>
</beans>


package com.bk.spring.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class SpringConDITest {

    public static void main(String a[]) {

        Resource res = new ClassPathResource("applicationContext.xml");
        BeanFactory factory = new XmlBeanFactory(res);
    
        EmployeeBean employeeBean = (EmployeeBean) factory.getBean("employeeBean");
        employeeBean.displayEmplyeeDetails();

    }

}

Setter injection in Spring

Setter injection is one of the approach to inject dependencies in Spring. We can use <property> element of <bean> tag to set the properties as shown below.

package com.bk.spring.test;

public class CourseBean {

    private String name;
    private String duration;
    private Double fee;

    public String getName() {
        return name;
    }

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

    public String getDuration() {
        return duration;
    }

    public void setDuration(String duration) {
        this.duration = duration;
    }

    public Double getFee() {
        return fee;
    }

    public void setFee(Double fee) {
        this.fee = fee;
    }
   
    public void getCourseDetails(){
        System.out.println("Course " + name + " has " + duration + " duration with fee " + fee);
    }

}

XML:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
      <bean name="courseBean" class="com.bk.spring.test.CourseBean">
    <property name="name" value="Java"></property>
    <property name="duration" value="90Days"></property>
    <property name="fee" value="2018"></property>
    </bean>
</beans>

Main test class:

package com.bk.spring.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class SpringConDITest {

    public static void main(String a[]) {

        Resource res = new ClassPathResource("applicationContext.xml");
        BeanFactory factory = new XmlBeanFactory(res);  
        CourseBean courseBean = (CourseBean) factory.getBean("courseBean");
        courseBean.getCourseDetails();

    }

}

Output : Course Java has 90Days duration with fee 2018.0

Overriden Of Hashcode() and Equal() methods in Java

We will see benefit by overriding the hashcode() and equals() methods in java.

JVM will assign unique hashcode value for each and every object created and if we did not over ride the hashcode()) method, no way to get same hashcode value for two objects.

As equals() method compare two objects if they have same value or not, then what is the need of overriding hashcode() method?

To answer this ,we need to know about how hashcode will work in java.

As mentioned in above diagram each java object will be placed in bucket depending on hashcode value. Here it is not necessary every different object does have different hashcode value.  Two different objects might have same hashcode.

When we try to insert key in hashmap, it will check and get the hashcode value  and find the bucket and insert the object into it if any other object is not available in the same bucket. If some other object is already available in that bucket, then it will check for equals() method on key and override if key is same other wise i.e key is different, it will insert the other object in next node of same bucket.

If object does not override hashcode() method,  and if we use the object as key to store, then we will not get the object back as shown below.

package com.sample.java.testing;

public class OverrideHascodeBean {

    private String name;
    private int id;

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

}


package com.sample.java.testing;

import java.util.HashMap;

public class OverrideHascodeEquals {

    public static void main(String a[]){
        HashMap<OverrideHascodeBean, String> hashMap = new HashMap<OverrideHascodeBean, String>();
       
        OverrideHascodeBean bean1 = new OverrideHascodeBean();
        bean1.setId(001);
        bean1.setName("Java");       
       
        OverrideHascodeBean bean2 = new OverrideHascodeBean();
        bean2.setId(002);
        bean2.setName("J2ee");       
       
        OverrideHascodeBean bean3 = new OverrideHascodeBean();
        bean3.setId(003);
        bean3.setName("Spring");       
       
        OverrideHascodeBean bean4 = new OverrideHascodeBean();
        bean4.setId(001);
        bean4.setName("Java");
       
        hashMap.put(bean1, "First");
        hashMap.put(bean2, "Second");
        hashMap.put(bean3, "Third");
        hashMap.put(bean4, "FirstDup");
       
        for (OverrideHascodeBean bean : hashMap.keySet()) {
            System.out.println(hashMap.get(bean).toString());
           
        }
       
        //creating object similar to first.
        OverrideHascodeBean bean5 = new OverrideHascodeBean();
        bean5.setId(001);
        bean5.setName("Java");
       
        if (hashMap.get(bean5) == null) {
            // here we created object(5) which is similar to object(1) but when
            // we try to get the bean from map it is not able to find. As we did
            // not override Hashcode() and equals() method, duplicate objects
            // are added not replaced even if we pass same key.
            System.out.println("Objectn not found");
           
        }
    }
}

Output : Third
First
FirstDup
Second
Objectn not found

See below example when we override equals and hashcode methods and we will find the object if we pass duplicate object.

package com.sample.java.testing;

public class OverrideHascodeBean {

    private String name;
    private int id;

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        OverrideHascodeBean bean = (OverrideHascodeBean) o;
        return bean.id == this.id && bean.name.equals(this.name);

    }

    @Override
    public int hashCode() {
        return name.hashCode() + id;
    }

}


package com.sample.java.testing;

import java.util.HashMap;

public class OverrideHascodeEquals {

    public static void main(String a[]){
        HashMap<OverrideHascodeBean, String> hashMap = new HashMap<OverrideHascodeBean, String>();
       
        OverrideHascodeBean bean1 = new OverrideHascodeBean();
        bean1.setId(001);
        bean1.setName("Java");       
       
        OverrideHascodeBean bean2 = new OverrideHascodeBean();
        bean2.setId(002);
        bean2.setName("J2ee");       
       
        OverrideHascodeBean bean3 = new OverrideHascodeBean();
        bean3.setId(003);
        bean3.setName("Spring");       
       
        OverrideHascodeBean bean4 = new OverrideHascodeBean();
        bean4.setId(001);
        bean4.setName("Java");
       
        hashMap.put(bean1, "First");
        hashMap.put(bean2, "Second");
        hashMap.put(bean3, "Third");
        hashMap.put(bean4, "FirstDup");
       
        for (OverrideHascodeBean bean : hashMap.keySet()) {
            System.out.println(hashMap.get(bean).toString());
           
        }
       
        //creating object similar to first.
        OverrideHascodeBean bean5 = new OverrideHascodeBean();
        bean5.setId(001);
        bean5.setName("Java");
       
        if (hashMap.get(bean5) == null) {
            // here we created object(5) which is similar to object(1) but when
            // we try to get the bean from map it is not able to find. As we did
            // not override Hashcode() and equals() method, duplicate objects
            // are added not replaced even if we pass same key.
            System.out.println("Objectn not found");
           
        }else{
            //as we override hashcode and equals method, hashmap will replace the old value with new value if we pass give duplicate key
            System.out.println("Object found");
        }
    }
}


output: Second
Third
FirstDup
Object found
 

Constructor Injection in Spring

Constructor injection is one of the approach to inject the dependency in spring  and we can inject the dependencies for primitive and string types using constructor method as shown below.

It requires spring core jar files to execute the below application.

1. Student bean which has some field to store student details. It is Bean in our example.
2. Application Context xml file to configure the student bean as spring bean.
3. Main class to execute the application.

Bean:

package com.bk.spring.test;

public class StudentBean {

    private int id;
    private String name;
    private String emailId;
    private String course;
    private double fee;

    StudentBean() {
        System.out.println("default constructor");
    }

    StudentBean(String name) {
        this.name = name;
    }
  
    StudentBean(int id) {
        this.id = id;
    }

    StudentBean(int id, String name, String emailId, String course, double fee) {
        this.id = id;
        this.name = name;
        this.emailId = emailId;
        this.course = course;
        this.fee = fee;
    }

    public void getStudentDetails() {
        System.out.println("Id is " + this.id + " name is " + name
                + " email id is " + emailId + " course is " + course
                + " fee is " + fee);
    }

}


Xml file:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean name="student" class="com.bk.spring.test.StudentBean">
        <constructor-arg value="001"/>
        <constructor-arg value="Krishna" />
        <constructor-arg value="krishna@abc.com" />
        <constructor-arg value="Spring" />
        <constructor-arg value="2018" />
    </bean>
</beans>

Execution Program:

package com.bk.spring.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class SpringConDITest {

    public static void main(String a[]) {

        Resource res = new ClassPathResource("applicationContext.xml");
        BeanFactory factory = new XmlBeanFactory(res);
        StudentBean bean = (StudentBean) factory.getBean("student");
        bean.getStudentDetails();

    }

}

Output : Id is 1 name is Krishna email id is krishna@abc.com course is Spring fee is 2018.0

If we comment all constructor args tags in xml file, then default constructor will call

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean name="student" class="com.bk.spring.test.StudentBean">
        <!-- <constructor-arg value="001"/>
        <constructor-arg value="Krishna" />
        <constructor-arg value="krishna@abc.com" />
        <constructor-arg value="Spring" />
        <constructor-arg value="2018" /> -->
    </bean>
</beans>
Output : default constructor
Id is 0 name is null email id is null course is null fee is 0.0

Similar way we cam initialize string parameterized constructor as shown below

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean name="student" class="com.bk.spring.test.StudentBean">
        <!-- <constructor-arg value="001"/> -->
        <constructor-arg value="Krishna" />
        <!-- <constructor-arg value="krishna@abc.com" />
        <constructor-arg value="Spring" />
        <constructor-arg value="2018" /> -->
    </bean>
</beans>

Output : Id is 0 name is Krishna email id is null course is null fee is 0.0

We need to take care of order of elements to pass like if i change the xml file as below, then second value will print email id. Just what ever we give test, it will assign to variable. No error but order also need to follow for our safety.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean name="student" class="com.bk.spring.test.StudentBean">
        <constructor-arg value="001"/>
        <constructor-arg value="krishna@abc.com" />
        <constructor-arg value="Krishna" />
        <constructor-arg value="Spring" />
        <constructor-arg value="2018" />
    </bean>
</beans>

Output: Id is 1 name is krishna@abc.com email id is Krishna course is Spring fee is 2018.0

Suppose if we have multiple single parameterized constructor and if we want to initialize specific constructor we need to specify the type and if we did not specify the type by default it will initialize the string parameterized constructor.

Below will call string param constructor;

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean name="student" class="com.bk.spring.test.StudentBean">
        <constructor-arg value="001"/>
        <!-- <constructor-arg value="Krishna" />
        <constructor-arg value="krishna@abc.com" />
        <constructor-arg value="Spring" />
        <constructor-arg value="2018" /> -->
    </bean>
</beans>

Output: Id is 0 name is 001 email id is null course is null fee is 0.0

Below will call int param constructor

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean name="student" class="com.bk.spring.test.StudentBean">
        <constructor-arg value="001" type="int"/>
        <!-- <constructor-arg value="Krishna" />
        <constructor-arg value="krishna@abc.com" />
        <constructor-arg value="Spring" />
        <constructor-arg value="2018" /> -->
    </bean>
</beans>

Output : Id is 1 name is null email id is null course is null fee is 0.0

Print different patterns using Java

We can print different pattern shapes using for loop in java programming.

package com.sample.java.testing;

public class PrintPatternTest {

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



*
**
***
****
*****
******
*******
********
*********
**********
     //===============================  
        for (int j = 9; j >= 0; j--) {
            for(int k =0; k <= j; k++){
                System.out.print("*");
            }
            System.out.println("");
           
        }

*********
********
*******
******
*****
****
***
**
*
//---------------------------------------------------       
        for (int j = 1; j < 9; j++) {
            for(int k =1; k <= j; k++){
                System.out.print(k);
            }
            System.out.println("");
           
        }
1
12
123
1234
12345
123456
1234567
12345678
//------------------------------------       
        for (int j = 9; j > 0; j--) {
            for(int k =2; k <= j; k++){
                System.out.print(k-1);
            }
            System.out.println("");
           
        }
12345678
1234567
123456
12345
1234
123
12
1
//============================       
        int startNumber = 1;
       
        for (int j = 0; j < 9; j++) {
            for(int k =0; k <= j; k++){
                System.out.print(startNumber + " ");
                startNumber = startNumber + 1;
            }
            System.out.println("");
           
        }
  1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35 36
37 38 39 40 41 42 43 44 45
//======================     
        int space = 9;
        for (int j = 0; j < 9; j++) {
            for(int k =0; k <= space; k++){
                System.out.print(" ");
            }
            space = space - 1;
            for (int i = 0; i < j+1; i++) {
                System.out.print("*");
            }
            System.out.println("");
        }
          *
         **
        ***
       ****
      *****
     ******
    *******
   ********
  *********
//------------------------------------------     
        int space1 = 9;
        for (int j = 0; j < 9; j++) {
            for(int k =0; k <= space1; k++){
                System.out.print(" ");
            }
            space1 = space1 - 1;
            for (int i = 0; i < j+1; i++) {
                System.out.print("* ");
            }
            System.out.println("");
        }
       
    }

}
           *
         * *
        * * *
       * * * *
      * * * * *
     * * * * * *
    * * * * * * *
   * * * * * * * *
  * * * * * * * * *

Some Interesting things in Java

As s java developer we need to know some of the basic but important things while coding. I found some of the below in my experience.

1. Divided by zero: Generally if we divide any number by using / operator , we will get arithmatic exception. Similarly, when some one asked me what is the output of 1/0.0, without any hesitation i said, it will give run time exception. But answer is wrong. Actually it will print INFINITY.

package com.sample.java.testing;

public class DividedByDoubleTest{

    public static void main(String[] args) {
        int i = 10;
        System.out.println(i / 0.0);//Infinity
        System.out.println(i % 0.0);//nan
       
        System.out.println(i / 2);//quotient
        System.out.println(i % 2);//reminder
        System.out.println(i % 0);//java.lang.ArithmeticException: / by zero
        System.out.println(i / 0);
    }

}


Output:
 Infinity
NaN
5
0
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.sample.java.testing.PrintTriAngleTest.main(PrintTriAngleTest.java:12)

2. Overriding: To override any method in sub class, we need to have same signature, return type and method name and  sub class can not modify the method behavior like it can not throws any exception if super class doe not do any like that.

Coming to Static method overridden it seems like overridden but actually not .Because static method is bind with class name. Hence we can have same static method name both is super class and subclass like separate methods not like Overridden.We can access super class static method with super class and subclass static method with subclass but coming to instance method, we can access the super class methods with subclass. And also we can access the overridden methods of subclass by using the parent class reference if we assign subclass object to parent class reference .This is what run time polymorphism.

We need multiple classes to get overridden feature.

3. Overloading:  One class can have different methods with same name but either argument return type or argument count should be different.

4. Static/Instance : We can access the static variables in side instance methods and also we can access static fields/methods using instance of class.  Because we are creating object for the class only so variables declared in class can be accessible using object of class which are either static or instance fields.Static filed will store in method area and when JVM loads the class first it loads static blocks/fields. But we can not access instance variable//methods using the class name because instance fields are accessible / memory allocated when we create the object and these are stored in heap memory.

5. Declaration : This is what just we have just write variable declaration etc.

String s;//Declaration
int k = 10;

6. Initiation: When we create object with new Keyword, then memory will allocate and reference for an object is created. So that we can access all the methods or fields using reference.


7. Initialization : Default values will be allocated for the filed into Memory. This is what happen by Constructor when we called. All variables will be initialized with some value in memory here.

ClassTest t;//Declaration
 t = new ClassTest(); //initiation and initialization memory and initialize the variable t.

Design Patterns In Java

Design patterns provides general solution for common design problems and initially design patterns were used in Object Oriented Programming. Later on realized that Design pattern need for other programming approaches to design software projects.

I general Programmers need some set of ideas/rules to design any use case or to develop any software application. In that case if we consider idea from already existing/developed application,  it will easy for us to implement that application and also it is time saving and effort saving process.

If we have some of problems in our application development and if we solve the problems by following some approach and if we share that approach we follows to solve an issue, it will be helpful for other to use the same approach instead of writing new solution. This approaches we can consider as design patterns.

So we can call a design pattern as a collection of rules which describes how to perform certain tasks during the software development.

Some of advantages of Design Patterns:

• They are already proved and verified as they have been built up on the knowledge and experience of developers.
• Design patterns are reusable ideas in multiple projects
• Design patterns captures the Software engineering experiences.  

We have Java/J2EE design patterns.

• Front controller design pattern
• Data Access Object (DAO) design pattern 
• Data Transfer Object (DTO) design pattern
• Singleton Design Pattern.
• Factory Desin Pattern
• Prototype Design Pattern

Front controller design pattern: It is J2EE design pattern used to handle multiple request in web application.

If we need of control which needs to handle and co ordinate  all coming multiple user request like consider a online shopping website. Here we need to maintain some sequence of steps and if multiple users are logged in at time, then we need to handle consistency among multiple users. So some piece of code performing input processing and scattered across multiple objects and it is difficult to change the behavior of an object at run time.

We can go for front controller design patterns to provide the solution for above problem. Here we can use Front controller to handle multiple requests.

With this design pattern implementation, every request  goes to front controller before it processed. The controller may forward the request to associate helper to verify authentication details of the user.
If we take Spring framework, Dispatcher controller will work as Front controller for application. i.e any request comes to server will be processed by dispatcher servlet.

Protoype Design Pattern in Java

Design patterns are programming language independent solution providers for specific problems. Design patterns will have some specific rules to provide solutions and we need to follow some rules to implement design pattern. We have different kind of design patterns for different types of problems. Suppose if we want to create class and we want to create only object for that class,  we can go for Singleton design pattern.

Suppose if we want to just clone the object instead of creating new one ,we can choose Prototype Design Pattern. We can also customize the cloned object as per our requirement if we use prototype design pattern. This pattern will follow java cloning feature.

Advantages:

1. With this design pattern, we can reduce the sub class mechanism.
2. It can add objects at runtime.
3. It avoids complexity to create objects.

Based on above advantages, we can go for this design pattern, if we come across any of above mentioned advantages like if we need objects which are slimier to already existing objects or if we need object creation dynamically at run time and if we want to perform some DB CRUD operations instead of creating new object every time to get data, we can clone existing one and can modify the data.

Example:

package com.sample.java.testing;

import java.util.ArrayList;
import java.util.List;

public class CoursePrototype implements Cloneable {

    List<String> courses;
  
    public CoursePrototype(){
        courses = new ArrayList<>();
    }
  
    public CoursePrototype(List<String> courses){
        this.courses = courses;
    }
  
    public void addCourse(){
        courses.add("J2SE");
        courses.add("J2EE");
        courses.add("Spring");
        courses.add("Hibernate");
    }
  
    public Object clone(){
        //if we do this temp list here, just we can clone object with list
        //other wise we need to call addcoures()method on each of cloned object
        List<String> tempCcourses = new ArrayList<>();
        for (String string : this.getCourseList()) {
            tempCcourses.add(string);
        }
        return new CoursePrototype(tempCcourses);
    }
  
    public List<String> getCourseList(){
        return courses;
    }
  

}


package com.sample.java.testing;

import java.util.List;

public class ProtoTypeDemoTest {

    public static void main(String[] args) {

        CoursePrototype coursePrototype = new CoursePrototype();
        coursePrototype.addCourse();
        System.out.println(coursePrototype.getCourseList());
        CoursePrototype cloneCoursePrototype = (CoursePrototype) coursePrototype.clone();
        //cloneCoursePrototype.addCourse();//as we already add dummy list inside clone method
        System.out.println(cloneCoursePrototype.getCourseList());//same as new object becoz we did not do any chnages
        List<String> list = cloneCoursePrototype.getCourseList();
        list.add("Design Pattern");//can modify as per our requirement
        System.out.println(cloneCoursePrototype.getCourseList());//it is different than original object
        System.out.println(coursePrototype.getCourseList());//no changes in original object
      
        CoursePrototype cloneCoursePrototype1 = (CoursePrototype) coursePrototype.clone();
        //cloneCoursePrototype1.addCourse();//as we already add dummy list inside clone method
        List<String> list1= cloneCoursePrototype1.getCourseList();
        list1.remove("Hibernate");//can modify as per our requirement
        System.out.println(cloneCoursePrototype1.getCourseList());//it is different than original object
    }

}


Output:
[J2SE, J2EE, Spring, Hibernate]
[J2SE, J2EE, Spring, Hibernate]
[J2SE, J2EE, Spring, Hibernate, Design Pattern]
[J2SE, J2EE, Spring, Hibernate]

IOC Vs DI

IOC Inversion of control: If someone else is creating the objects for us rather than we are creating using new Object and we can call that some one as IOC container. i.e IOC container will take the part of creating Objects which we needed. As object is inverted we are calling it is Inversion of Control. It is not programmer, some one else who controlling the object.

If we consider Spring framework, Spring IOC will take of Bean creations.

Dependency Injection: We normally hardcode the dependency as shown below.

package com.sample.java.testing;

public class DependentObjectTest {

    DependencyObjectTest dependentObjectTest;
   
    DependentObjectTest(){
        dependentObjectTest = new DependencyObjectTest();//tight coupling
    }

}

DI is nothing but injecting the dependency rather than hardcoding it. WE can inject the dependency either  setter method and constructor.

Constructor Injection:

package com.sample.java.testing;

public class DependentObjectTest {

    DependencyObjectTest dependentObjectTest;
   
       DependentObjectTest(DependencyObjectTest dependentObjectTest){
        this.dependentObjectTest = dependentObjectTest;       
    }
}

Setter Injection:

package com.sample.java.testing;

public class DependentObjectTest {

    DependencyObjectTest dependentObjectTest;
   
     public DependencyObjectTest getDependentObjectTest() {
        return dependentObjectTest;
    }

    public void setDependentObjectTest(DependencyObjectTest dependentObjectTest) {
        this.dependentObjectTest = dependentObjectTest;
    }
     
}

Multi level dependecy: like class1 depends on class2 and classs2 is dependent on class3 etc.

package com.sample.java.testing;

public class DependencyObjectTest {
   
    public void printMessage(){
        System.out.println("DependencyObjectTest printMessage");
    }

}

package com.sample.java.testing;

public class Dependent1 {

    DependencyObjectTest dependencyObjectTest;
   
    Dependent1(DependencyObjectTest dependencyObjectTest){
        this.dependencyObjectTest =dependencyObjectTest;
    }
   
    public void printMessage(){
        System.out.println("Dependent1 printMessage");
        dependencyObjectTest.printMessage();
    }
}

package com.sample.java.testing;

public class Dependent2 {
   
    Dependent1 dependent1;
   
    Dependent2(Dependent1 dependent1){
        this.dependent1 = dependent1;
    }
   
    public void printMessage(){
        System.out.println("Dependent2 printMessage");
        dependent1.printMessage();
    }

}

package com.sample.java.testing;

public class Dependent3 {

    Dependent1 dependent1;
    Dependent2 dependent2;
   
    Dependent3(Dependent1 dependent1, Dependent2 dependent2){
        this.dependent1 = dependent1;
        this.dependent2 = dependent2;
    }
   
    public void printMessage(){
        System.out.println("Dependent3 printMessage");
        dependent1.printMessage();
        dependent2.printMessage();
    }
}

package com.sample.java.testing;

public class DependentDemoTest {

    public static void main(String[] args) {

        DependencyObjectTest dependencyObjectTest = new DependencyObjectTest();
        Dependent1 dependent1 = new Dependent1(dependencyObjectTest);
        Dependent2 dependent2 = new Dependent2(dependent1);
        Dependent3 dependent3 = new Dependent3(dependent1, dependent2);
        dependent3.printMessage();
    }

}

What is Spring Framework

Spring framework is one of mostly used framework for Enterprise application development.
Spring is multi-tier open source lightweight application framework. Spring framework provides support to simplify the development of  enterprise application in each and every layer. It also support to integrate various other frameworks with it if required. We can implement the complete enterprise application using with spring framework alone.

Dependency injection and Inversion Of Control(IOC):

Spring framework implements the IOC principle to made dependency injection very easy and flexible. We can remove the dependency or tight coupling in between java classes with IOC.

Consider below sample programms.

package com.sample.java.testing;

public class DependencyObjectTest {

}


package com.sample.java.testing;

public class DependentObjectTest {

    DependencyObjectTest dependentObjectTest;
  
    DependentObjectTest(){
        dependentObjectTest = new DependencyObjectTest();//tight coupling
    }
  
 }

Here we have  dependency in between DependecyTest  and DependentObjectTest  objects. these are tightly coupled. Ad if we made changes to resource, we need to do some code changes in our classes as well.

The same can be achieved with IOC as shown below by removing the dependency at compile time.

package com.sample.java.testing;

public class DependentObjectTest {

    DependencyObjectTest dependentObjectTest;

    DependentObjectTest(DependencyObjectTest dependentObjectTest){
        this.dependentObjectTest = dependentObjectTest;      
    }
}


Here both object are loosely coupled i.e if we no need to make any changes from client side, even if we made any changes to resource.

Dependency Injection(DI):

Dependency Injection is design pattern which implements IOC principle to remove the dependencies from programming. Hence we can manage application easily. Dependency Injection will make our code as loosely coupled which makes it decreases the coupling between class and it's dependency object.

Advantages of  Spring Framework: Below are some of advantages we get with Spring Framework

1. Lightweight
2. Inversion of Control which helps loose coupling in between classes.
3. Declarative support
4. Easy and fast Development

Factory Design Pattern in Java

We will use Factory design pattern when we have one super class and many sub classes and we need to return instance of subclass based on input.  Factory class will take the responsibility for object creation instead of client program

Super Class:
package com.sample.java.testing;

public abstract class FactoryPatternVehicleClass {
   
    public abstract int getWheels();
    public abstract String getEngineType();
   
    @Override
    public String toString(){
        return this.getEngineType() + " has " + this.getWheels() + " wheels";
    }

}

Subclass1:
package com.sample.java.testing;

public class FactoryPatternCarClass extends FactoryPatternVehicleClass {

    int noOfWheels;
    String engineType;

    public FactoryPatternCarClass(int noOfWheels, String engineType) {
        this.noOfWheels = noOfWheels;
        this.engineType = engineType;
    }

    @Override
    public int getWheels() {
        return this.noOfWheels;
    }

    @Override
    public String getEngineType() {

        return this.engineType;
    }

}

Subclass2:
 
package com.sample.java.testing;

public class FactoryPatternBusClass extends FactoryPatternVehicleClass {

    int noOfWheels;
    String engineType;

    public FactoryPatternBusClass(int noOfWheels, String engineType) {
        this.noOfWheels = noOfWheels;
        this.engineType = engineType;
    }

    @Override
    public int getWheels() {
        return this.noOfWheels;
    }

    @Override
    public String getEngineType() {

        return this.engineType;
    }

}

Factory class to return Objects:
 
package com.sample.java.testing;

public class FactoryPatternFactoryClass {

    public static FactoryPatternVehicleClass getVehicleObject(
            String objectType, int noOfWheels) {

        if (null != objectType && objectType.equalsIgnoreCase("Bus")) {
            return new FactoryPatternBusClass(noOfWheels, objectType);
        } else if (null != objectType && objectType.equalsIgnoreCase("Car")) {
            return new FactoryPatternBusClass(noOfWheels, objectType);
        }
        return null;

    }

}

Client class to test:
 
package com.sample.java.testing;

public class FactoryPatternDemoTest {

    public static void main(String a[]) {
        FactoryPatternVehicleClass factoryPatternBusClass = FactoryPatternFactoryClass
                .getVehicleObject("Bus", 6);
        System.out.println(factoryPatternBusClass);

        FactoryPatternVehicleClass factoryPatternCarClass = FactoryPatternFactoryClass
                .getVehicleObject("Car", 4);
        System.out.println(factoryPatternCarClass);
    }
}

Output:

Bus has 6wheels
Car has 4wheels
 

How HashMap works internally in Java

One of the most popular and important java interview question is how Hashmap will works and how it is different from Hashtable.

Hashmap will work on hashing principle. But it is not as easy as it seems. Hashing is mechanism to assigning unique hashcode to variable or attribute using algorithm for easy retrieve of elements. Hence best hashing algorithm should return same hashcode every time when it is applied on same object.
We will see below how hashing helps to store and retrieve elements from hashmap?.
Hashing uses hash functions to link key and value in Hashtable. We will store elements using put(key, value) and retrieve using get(key) methods from Hashmap.

When we call put method on Hashmap, hashcode() method of key is called and map will find the bucket location buy using hash function and stores value object in bucket. Here bucket is nothing but index of an internal array and it is known as table. Hashmap internally stores mapping in the form of Map.Entry object which contains both key and value objects.

Put method implementaion:

/**
     * Associates the specified value with the specified key in this map.
     * If the map previously contained a mapping for the key, the old
     * value is replaced.
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @return the previous value associated with <tt>key</tt>, or
     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
     *         (A <tt>null</tt> return can also indicate that the map
     *         previously associated <tt>null</tt> with <tt>key</tt>.)
     */
    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

And when we try to retrieve elements by using get() method, we need to pass key value and here key object will generate same hashcode(generated when storing and it is mandatory to generate same hashcode to retrieve object. This is the reason Hashmap keys are immutable Ex: Strings) so that we can get the bucket location. If  we have only one Map.entry object, we can get it and this is object we stored earlier. But if we have any collision here, it will require more understanding to retrieve elements from same bucket location.

Get Method implementation:

/**
     * Returns the value to which the specified key is mapped,
     * or {@code null} if this map contains no mapping for the key.
     *
     * <p>More formally, if this map contains a mapping from a key
     * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
     * key.equals(k))}, then this method returns {@code v}; otherwise
     * it returns {@code null}.  (There can be at most one such mapping.)
     *
     * <p>A return value of {@code null} does not <i>necessarily</i>
     * indicate that the map contains no mapping for the key; it's also
     * possible that the map explicitly maps the key to {@code null}.
     * The {@link #containsKey containsKey} operation may be used to
     * distinguish these two cases.
     *
     * @see #put(Object, Object)
     */
    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

Internal array of Hashmap as fixed size and if we are adding more elements into the map, we will get same bucket location for other objects at some point of time. i.e same bucket will return for two different keys and it will store both Map.Entry objects in same bucket. In this case it uses LinkedList inside the same bucket to store the entry objects. i.e it will store new entry object in next node of same bucket.

If we try to retrieve elements from collision bucket, we require one more check to get correct value and it uses equals() method on key value to return correct entry object.  If we get one bucket from key hashing mechanism and if t has two nodes for two entry objects and if we want to get correct entry, Hashmap compares the entry key Object using equals() method and if it return true, then map returns corresponding entry object.

Overridden of value if key is duplicate: Consider below hashmap sample:

package com.sample.java.testing;

import java.util.HashMap;

public class HashMapTest {

    public static void main(String[] args) {

        HashMap hashMap = new HashMap<>();
        hashMap.put("Course", "Java");
        hashMap.put("Course", "J2EE");
        hashMap.put("Course", "Spring");
        hashMap.put("Subject", "Servlet");
        System.out.println(hashMap);
    }

}

Here we will get output as {Course=Spring, Subject=Servlet} because Course Key will override all previous values. Why because all entries will be stored ad linked list if hashcode bucket is same for multiple keys and in that case it uses key.equals("Course") method on keys to inserting/retrieving data. Hence it replace the old values as equals() method will give true if key is same.

Null as Key: If we put null as key in Hashmap it will go to first index of table i.e 0th bucket because hashcode of null is Zero.

Singleton Design Pattern in JAVA

From name Singleton, this pattern restricts the object instantiate and ensures it have only one instance of class is available in JVM and it has below characteristics.

1. Singleton pattern object instantiate and ensures it have only one instance of class is available in JVM.
2. Class should have global access to provide the instance of object.
3. Most commonly used singleton pattern is for Logging in java application.

We have different approaches to implement singleton design pattern and should follow below common points.

1. Constructor should be private so that we other classes can not create object using constructor.
2. Class should have one public static variable to hold the instance of class.
3. Class should have public static method to return the object of class. Application should get the instance of class by using this method. Hence this method should have global access across application.

Singleton Early initiation:

 In this approach object of class in created when it is loaded even client is not request for this object.

package com.sample.java.testing;

public class SingletonEagerInitiationTest {

    public static SingletonEagerInitiationTest eagerInitiationTest = new SingletonEagerInitiationTest();

    private SingletonEagerInitiationTest() {

    }

    public static SingletonEagerInitiationTest getInstance() {
        return eagerInitiationTest;
    }
}

But generally we should avoid object creation early until unless  some other classes required it. And also we do not perform any exception handling.

Static block initiation

In this approach we can provide object creation using static block with exception handling.
package com.sample.java.testing;

public class SingletonStaticInitiationTest {

    public static SingletonStaticInitiationTest initiationTest;

    private SingletonStaticInitiationTest(){
      
    }
  
    static {
        try {
            initiationTest = new SingletonStaticInitiationTest();
        } catch (Exception e) {
            System.out.println("failed to initialize object" + e);
        }
    }

    public static SingletonStaticInitiationTest getInstance() {
        return initiationTest;
    }
}

In this approach also object will initialize early even any other classes are not accessed to this object. We can void this by using Lazy Initiation.

In lazy initiation approach, it won't create object while class loading. It will create object and returns when any other class accessed getInstance() method.


package com.sample.java.testing;

public class SingletonLazyInitiationTest {

    public static SingletonLazyInitiationTest singletonLazyInitiationTest;

    private SingletonLazyInitiationTest() {

    }

    public static SingletonLazyInitiationTest getInstance() {

        try {
            if (singletonLazyInitiationTest == null) {
                singletonLazyInitiationTest = new SingletonLazyInitiationTest();
                return singletonLazyInitiationTest;
            } else {
                return singletonLazyInitiationTest;
            }
        } catch (Exception e) {
            System.out.println("failed to initialize object" + e);
            return null;
        }
    }
}

Here if we are using multiple threads, and two different threads are trying to access the
getInstance() method, it will breaks the singleton pattern. Hence we should follow below approach in multi thread environment by making  getInstance() method as synchronized.

package com.sample.java.testing;

public class SingletonSyncronizedIntitiationTest {

    public static SingletonSyncronizedIntitiationTest singletonSyncronizedIntitiationTest;

    private SingletonSyncronizedIntitiationTest() {

    }

    public static synchronized SingletonSyncronizedIntitiationTest getInstance() {

        try {
            if (singletonSyncronizedIntitiationTest == null) {
                singletonSyncronizedIntitiationTest = new SingletonSyncronizedIntitiationTest();
                return singletonSyncronizedIntitiationTest;
            } else {
                return singletonSyncronizedIntitiationTest;
            }
        } catch (Exception e) {
            System.out.println("failed to initialize object" + e);
            return null;
        }
    }
}



Here even if multiple threads can not get access to getInstance() method as it is synchronized. But it will impact on performance.

String Vs String Buffer Vs String Builder

String is very important and most commonly used object in java programming and we should know some important features of String as a java developer. Here we will some of the important features of string and how it is different from String builder and String buffer.

String:

• String class is represents as characters ans we can create string object as 

               String s ="java" or String s =new String("java");

• When we create String with double quotes, first it will check whether same string is available in string pool or not and based on it;s existence, it will create new string in pool or return existing reference. This approach will save lot of memory by using same string  for multiple threads. But here if we go for new operator to create string object, it will create new memory in heap memory. Every string created with new operator will create memory in heap.

• String is immutable in java and we can share it to different functions , classes and threads safely and String is final class and fields also are final except hashcode .

• Two string are equal only when both strings have same characters in same order. And String equals() method is case sensitive. We can go for equalsIgnoreCase() if we do not want to check for case sensitive.

String Vs String Buffer Vs String Builder

Since String is immutable object and if we perform operation like concat() and assign it to existing string, it will create new string and delete the old string for Garbage Collection.

        String string1 = "java";
        string1.concat("wleomce");
        System.out.println(string1);// it will print javaonly
        but if we do below
        string1 = string1.concat("language");
        System.out.println(string1);// it will print java language and it deletes "java" literal

So if we do these operation on string, will create lot of garbage on heap. Hence Java provided StringBuilder and StringBuffer classes to manipulate the strings.

Both StringBuilder and StringBuffer are mutable objects and we can perform append(), delete(), subString() etc methods on string object.

StringBuilder vs StringBuffer

1. Thread Safety : Both are mutable classes but StringBuilder is synchronized and all method are synchronized. String builder provided thread safety but it effects on performance. Hence java provided new class StringBuffer in JDKversion 5. StringBuffer is similar to String builder but it omits thread safety and it is not synchronized. Hence we can use StringBuilder in single thread environment else use StringBuffer.

2. Performance: Due to synchronization and thread safety, StringBuffer is less efficient on performance when compared to StringBuilder.

package com.sample.java.testing;

public class StringBuilderTest {

    public static void main(String[] args) {

        String s = "java";
        StringBuilder builder = new StringBuilder(s);
        builder.append(" is OOP language");
        System.out.println(builder.toString());//java is OOP language
    }

}

package com.sample.java.testing;

public class StringBufferTest {

    public static void main(String[] args) {

        String s ="Welcome to java";
        StringBuffer buffer = new StringBuffer(s);
        buffer.delete(0, 10);
        System.out.println(buffer);// java
    }

}

Below are some of basic differences in between String , StringBuffer and StringBuilder

• String is immutable class where as StringBuffer and StringBuilder are mutable classes.
• StringBuffer is thread Safe and StringBuilder is not thread safe
• String Builder class is useful to manipulate String in single thread environment where as StringBuffer will be useful to manipulate String in multi thread environment as it is thread safe.

Comparator Vs Comparable interface in java

Both Comparator and Comparable interfaces provide features to sort the collections of Objects. However java provided some default methods to sort primitive types arrays and array of objects etc using .sort() method etc, we will use Comparator and comparable interfaces  to sort collections.

We will get all details how to use Comparable and Comparator interfaces in my previous posts. Here we can find some basic differences between Comparable and Comparator interface.

1.  Sorting : We can sort in single way  with Comparable Interface. like we can apply sorting with one of the property of bean to sort list of beans.

@Override
    public int compareTo(EmployeeComparableClass o) {
        return this.getId() - o.getId(); // compare based on id
    }

We can sort collection of objects in different ways using Comparator interface. We can write our custom comparator classes and can use different properties to sort the collections.

//compare and sort based on emp is
@Override
    public int compare(EmployeeClass o1, EmployeeClass o2) {
        return o1.getId() - o2.getId();
    }

or

//compare and sort based on emp name
    @Override
    public int compare(EmployeeClass o1, EmployeeClass o2) {
        return o1.getName().compareTo(o2.getName());
    }

2. Implements: Class needs to implement Comparable class  in order to sort.
Class no need to do any implement if we go for Comparator. We can crate new comparator classes by implementing the comparator interfaces.

To sort employee, we need to implement Comparable interface as shown below.
public class EmployeeComparableClass implements Comparable<EmployeeComparableClass>

It is not required if we go for Comparator interface.

3. Package: Comparable interface is available under java.lang package where as Comparator interface is available in java.util package

4.Code changes: We no need to do any code changes from client side if we go for Arrays.sort(), Collections.sort() and Comparable interfaces. Here these will use compareTo() method automatically.

We need to do code changes at client side if we go for Comparator interface.  Here Client needs to provide comparator class to use compare() method.

Ex: Detailed example is available @Comparable and Comparator

Sorting method

int[] numbers = new int[] { 1, 6, 3, 8, 9 };
        System.out.println("without sort " + Arrays.toString(numbers));
        Arrays.sort(numbers);
        System.out.println("sort array " + Arrays.toString(numbers));

Comparator:

List<EmployeeClass> employess = new ArrayList<>();
        employess.add(employeeClass3);
        employess.add(employeeClass2);
        employess.add(employeeClass1);
        employess.add(employeeClass);
        System.out.println("before comarator sorting....");
        for (EmployeeClass employeeClass4 : employess) {
            System.out.println(employeeClass4.toString());// no order it will print emp details randomly
        }
       
        System.out.println("after comarator sorting using emp name....");
        Collections.sort(employess, new ComparatorNameTest());

Comparable:
EmployeeComparableClass[] classes = new EmployeeComparableClass[4];
       
        EmployeeComparableClass employeeClass = new EmployeeComparableClass(60, "Java", 345678);
        EmployeeComparableClass employeeClass1 = new EmployeeComparableClass(50, "J2ee", 9876543);
        EmployeeComparableClass employeeClass2 = new EmployeeComparableClass(30, "Spring", 12345);
        EmployeeComparableClass employeeClass3 = new EmployeeComparableClass(40, "Jdbc", 654);
        classes[0] = employeeClass;
        classes[1] = employeeClass3;
        classes[2] = employeeClass2;
        classes[3] = employeeClass1;
        // below it will throw an runtime exception
        //Exception in thread "main" java.lang.ClassCastException: com.sample.java.testing.EmployeeClass cannot be cast to java.lang.Comparable
        //hence  EmployeeComparableClass implement Comparable interface
        //SO by using comparable we can sort the list based on
        System.out.println("sorting list as per comparable...");
        Arrays.sort(classes);
        for (EmployeeComparableClass course : classes) {
            System.out.println(course.toString());// sorting based on id
        }