Lazy Loading in Java

The concept of delaying the loading of an object until one needs it is known as lazy loading. In other words, it is the process of delaying the process of instantiating the class until required. Lazy loading is important in a scenario where the cost of creating objects is high, or usage of the object is rare in the program. Lazy loading is a technique that enhances the efficiency of the program. In this section, we will discuss lazy loading in detail.

Implementations of Lazy Loading

Virtual Proxy

Virtual proxy is the memory saving process that promotes the postponement of object creation. Observe the following program.

FileName: LazyLoadingExample.java

  // Java program that shows virtual proxy in the Lazy Loading     // import statements  import java.util.ArrayList;  import java.util.List;    // declaring an interface  interface IContactList  {  public List getEmployeesList();  }    class Company  {  // fields of the company class  String cName;  String cAddress;  String cContactNo;  IContactList contctList;    // constructor of the list for  initializing the class fields  public Company(String cName, String cAddress, String cContactNo, IContactList contctList)  {  this.cName = cName;  this.cAddress = cAddress;  this.cContactNo = cContactNo;  this.contctList = contctList;  }    // a getter method to retrieve the company name  public String getCompnyName()  {  return this.cName;  }    // a getter method to retrieve the address of the company  public String getCompnyAddress()  {  return this.cAddress;  }  public String getCompnyContactNo()  {  return this.cContactNo;  }    // a getter method to retrieve the contact list  public IContactList getContctList()  {  return this.contctList;  }    }    class ContactList implements IContactList   {  // a method to retrieve the list  @Override  public List getEmployeesList()  {  return getEmpList();  }  private static List getEmpList()  {  List empList = new ArrayList(5);    // adding employees to the list  empList.add(new Employees(“Mukesh”, 3452.67, “JSE”));  empList.add(new Employees(“Amit”, 22345, “ASE”));  empList.add(new Employees(“Naman”, 3256.17, “G4”));  empList.add(new Employees(“Vipul”, 4895.34, “SDE1”));  empList.add(new Employees(“Akhil”, 2857.91, “SDE2”));    return empList;  }  }    class ContactListProxy implements IContactList   {    private IContactList contctList;    @Override  public List getEmployeesList()  {  if (contctList == null)   {  System.out.println(“Fetching the list of employees … n”);  contctList = new ContactList();  }  return contctList.getEmployeesList();  }  }    class Employees  {  // fields of the employees class  private String empName;    private double empSalary;  private String empDesignation;    // constructor of the list for initializing the class fields   public Employees(String empName, double empSalary, String empDesignation)  {  this.empName = empName;  this.empSalary = empSalary;  this.empDesignation = empDesignation;  }    // a getter method to get employee name  public String getEmpName()  {  return empName;  }      // a getter method to retrieve the employee salary  public double getEmpSalary()  {  return empSalary;  }    // a getter method to fetch the designation of the employee  public String getEmpDesignation()  {  return empDesignation;  }    @Override  public String toString()  {  String res = “Employee Name: ” + empName + “, EmpDesignation : ” + empDesignation + “, Employee Salary : ” + empSalary;    return res;  }  }    // main class  public class LazyLoadingExample  {  // main method  public static void main(String[] argvs)  {  // instantiating the ContactListProxy class   IContactList contactListObj = new ContactListProxy();      // instantiating the company class  Company companyObj = new Company(“ABC”, “India”, “+91-011-55512347”, contactListObj);    System.out.println(“Company Name: ” + companyObj.getCompnyName());  System.out.println(“Company Address: ” + companyObj.getCompnyAddress());  System.out.println(“Company Contact No.: ” + companyObj.getCompnyContactNo() + “n”);  System.out.println(“Requesting for the contact list …”);    contactListObj = companyObj.getContctList();  List employeeList = contactListObj.getEmployeesList();    // printing the fetched list  for (Employees emp : employeeList)   {  System.out.println(emp);  }  }  }  

Output:

Company Name: ABC  Company Address: India  Company Contact No.: +91-011-55512347    Requesting for the contact list ...  Fetching the list of employees ...     Employee Name: Mukesh, EmpDesignation : JSE, Employee Salary : 3452.67  Employee Name: Amit, EmpDesignation : ASE, Employee Salary : 22345.0  Employee Name: Naman, EmpDesignation : G4, Employee Salary : 3256.17  Employee Name: Vipul, EmpDesignation : SDE1, Employee Salary : 4895.34  Employee Name: Akhil, EmpDesignation : SDE2, Employee Salary : 2857.91

Explanation: In the code, we have instantiated the ContactListProxy class. At this point, the list of employees is not created. It is because the list of employees is not required at this point of time. When the list of employees is required, the method getEmployeeList() is invoked, and at the same time, the list of employees is created, which shows the creation of the list of employees is delayed until required.

Lazy Initialization

The Lazy Initialization technique demonstrates the value check of a class field when its usage is required used. If that class field value is null, then the field gets updated with the proper value before it is returned. The following example illustrates the same.

File Name: LazyLoadingExample1.java

  // A Java program that shows the  // Lazy Initialization    // import statements  import java.util.Map;  import java.util.HashMap;  import java.util.Map.Entry;  enum CarsType   {  BMW,  Mercedes,  Audi  }    class Cars   {  // a class field that stores CarsType as key and its object as its value.  private static Map typesMap = new HashMap<>();    // constructor of the class Cars is made private  private Cars(CarsType type)   {    }    public static Cars getCarByTypeName(CarsType type)  {  Cars carObj;    // check whether the type is present in the map or not  // if not present load the type in the map typesMap  if (!typesMap.containsKey(type))   {    carObj = new Cars(type);  typesMap.put(type, carObj);  }   else   {  // It is available currently  carObj = typesMap.get(type);  }    return carObj;  }    public static void displayAll()  {  // calculating size of the map  int size = typesMap.size();    // display only when the map is not empty  if (size > 0)   {    System.out.println(“The number of instances created = ” + size);    // iterate over each entry of the typesMap map and display them  for (Entry entry : typesMap.entrySet())   {  String cars = entry.getKey().toString();  cars = Character.toUpperCase(cars.charAt(0)) + cars.substring(1);  System.out.println(cars);  }    System.out.println();  }  }  }  // main class  public class LazyLoadingExample1   {  // main method  public static void main(String argvs[])  {  Cars.getCarByTypeName(CarsType.Mercedes);  Cars.displayAll();  Cars.getCarByTypeName(CarsType.Audi);  Cars.displayAll();  Cars.getCarByTypeName(CarsType.BMW);  Cars.displayAll();  }  }  ,>,>

Output:

The number of instances created = 1  Mercedes    The number of instances created = 2  Audi  Mercedes    The number of instances created = 3  Audi  BMW  Mercedes

Explanation: In the code, the getCarByTypeName() method does the lazy initialization of the map field. It first checks whether the asked car type is present or not. If not present, the concerned car type is instantiated and then loaded on the map. Note that the constructor of the class Cars is made private intentionally. The private constructor ensures that one cannot create an object of the class Cars at any time. An instance of the class Cars is only created when we invoke the method getCarByTypeName(), which shows that an appropriate instance of the class Cars is only created or loaded when required.

Next TopicRectangular Number in Java

Lazy Loading in Java

Lazy Loading in Java

Implementations of Lazy Loading

Virtual Proxy

Lazy Initialization

Java String toUpperCase() method

LinkedHashMap vs HashMap

You may also like