DEV Community: Rajesh Mishra

Simplify JSON Data Like Never Before!

Rajesh Mishra — Fri, 28 Mar 2025 20:03:21 +0000

Are you tired of dealing with complex, unreadable JSON data? Say hello to JSON Visualizer your go-to tool for formatting, analyzing, querying, transforming JSON.

Interactive Graphs – Convert JSON into easy-to-read visual structures.
Smart Formatting – Beautify and optimize JSON instantly.
Validation & Debugging – Identify errors in real time.
Seamless Integration – Works smoothly across various formats and environments.

Whether you're a developer, data analyst, or just working with JSON files, this tool makes your life easier!

Try it now https://jsonvisualizer.com/

Let us know how JSON Visualizer has helped you! Drop a comment or share your thoughts.

Building a Scalable Notification System: A Deep Dive into Design and Architecture

Rajesh Mishra — Sun, 18 Aug 2024 20:49:13 +0000

In today’s fast-paced digital world, ensuring timely and reliable communication with users is crucial for businesses. Whether it’s a transaction alert, a promotional email, or an SMS notification, the need for a system that can handle massive volumes of messages efficiently is more important than ever. Enter the Scalable Notification System—a robust architecture designed to manage and deliver notifications seamlessly across various channels. In this blog post, we’ll break down the components and workflow of this system to show you how it all comes together.

What is a Scalable Notification System?

A Scalable Notification System is an architecture built to handle high volumes of notifications, ensuring that every message, whether critical or non-critical, reaches the end user through the appropriate channel—be it email, SMS, or social media. The system is designed to prioritize critical messages while ensuring non-critical ones are delivered without disrupting the flow of important communications.

Key Components of the System

Data Source (DB or File): Every notification starts with data. The system pulls this data from a database or file, which serves as the source of information for the notifications. This data includes everything from transaction details to promotional content, and it’s fed directly into the system for processing.
Scalable Queuing Node (SQN): At the heart of the system lies the Scalable Queuing Node (SQN). Think of it as the traffic cop that directs messages into the right lanes—critical or non-critical. The SQN manages the flow of messages, categorizing them based on their urgency, and ensures that the system can handle varying loads by scaling up as needed.
Handling Critical Messages (Transactional Messages): Critical messages, like transaction alerts or reminders, are given top priority in this system. These messages are funneled into dedicated queues, where they are processed by specialized workers. This ensures they are sent out quickly and efficiently, minimizing any delays.
Managing Non-Critical Messages (Promotional Messages): Non-critical messages, such as promotional emails or marketing SMS, are handled separately. These messages don’t require immediate attention, allowing the system to process them in a way that doesn’t interfere with the delivery of critical notifications.
Queues: The Backbone of Delivery To manage the delivery of messages to various channels, the system uses different queues:
- Social Media Queue: For notifications that need to be posted on social media platforms.
- Email Queue: Specifically for email notifications.
- SMS Queue: For text messages that need to be sent out.
- Priority Queues: Dedicated to handling the most critical messages that need to be sent out immediately. Each queue ensures that messages are processed in the correct order and delivered through the appropriate channels.
Sender API: The Final Step in Delivery The Sender API is the bridge between the system and the end user. Once a message has been processed and queued, the Sender API takes over, delivering the notification to the user through the chosen channel. Whether it’s an email, a text message, or a social media update, the Sender API ensures that every notification reaches its destination.
End User: The Ultimate Recipient The end goal of the system is to ensure that notifications reach the end user without delay. The architecture is designed to deliver messages in a timely and efficient manner, ensuring that users receive the information they need when they need it.

Scalability and Reliability

One of the standout features of this notification system is its scalability. As the volume of messages increases, the system can scale horizontally by adding more workers and resources. This ensures that performance remains consistent, even during peak times.

By segregating critical and non-critical messages, the system ensures that important notifications are never delayed. The use of multiple queues and worker nodes allows the system to manage a large volume of messages efficiently, maintaining a high level of reliability.

How It All Works: The Operational Flow

Data Input: The process begins with data input from a source (database or file). Messages are then categorized into critical and non-critical types.
Message Categorization: The SQN processes the incoming data, directing critical messages into priority queues and non-critical messages into other queues.
Queue Processing: Workers assigned to each queue process the messages in the order of priority, ensuring that critical messages are handled first.
Message Delivery: The Sender API retrieves messages from the queues and delivers them to the end user via the appropriate channels.
User Reception: Finally, the end user receives the notification through their preferred platform, whether it’s social media, email, or SMS.

Conclusion

The Scalable Notification System is a powerful solution for managing high volumes of notifications. Its modular design allows it to scale effortlessly, making it an ideal choice for businesses that require reliable and efficient message delivery. Whether you’re sending critical alerts or promotional content, this system ensures that your messages reach the right people at the right time.

Read more about system design on howtostartprogramming.in

What is Solid Design Principle in Java?

Rajesh Mishra — Sun, 11 Aug 2024 21:20:28 +0000

The SOLID design principles in Java are a set of guidelines that help developers create robust, scalable, and maintainable software. These principles are foundational in object-oriented programming and play a critical role in ensuring that your codebase remains flexible and adaptable as it evolves. Let’s break down what SOLID means and why it’s essential:

1. S - Single Responsibility Principle (SRP)

Definition: A class should have only one reason to change, meaning it should only have one responsibility or job.
Why It Matters: This principle makes your code easier to understand, test, and maintain. When a class is focused on a single task, it reduces the risk of bugs and makes it easier to refactor without affecting other parts of your system.
Example: SRP

2. O - Open/Closed Principle (OCP)

Definition: Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification.
Why It Matters: This principle allows you to extend the behavior of a class without modifying its existing code. It’s crucial for building flexible and scalable systems, as it reduces the chances of introducing new bugs when you add new features.
Example: OCP

3. L - Liskov Substitution Principle (LSP)

Definition: Subtypes must be substitutable for their base types without altering the correctness of the program.
Why It Matters: This principle ensures that derived classes enhance, rather than replace, the functionality of their base classes. It helps in maintaining the integrity of your code and ensures that components remain interchangeable.
Example: LSP

4. I - Interface Segregation Principle (ISP)

Definition: No client should be forced to depend on methods it does not use. Essentially, interfaces should be specific to the needs of the client.
Why It Matters: This principle reduces the burden on implementing classes and prevents them from being bloated with unnecessary methods. It makes your code more modular, easier to understand, and simpler to maintain.
Example: ISP

5. D - Dependency Inversion Principle (DIP)

Definition: High-level modules should not depend on low-level modules. Both should depend on abstractions. Also, abstractions should not depend on details; details should depend on abstractions.
Why It Matters: This principle helps in decoupling your code, making it more resilient to changes and easier to manage. It encourages the use of interfaces or abstract classes, leading to a more flexible and testable codebase.
Example: DIP

Why SOLID Principles are Essential in Java Development

By adhering to the SOLID principles, you create a codebase that is:

Maintainable: Easier to modify and extend as your project grows.
Understandable: Clearer structure, making it easier for other developers to read and contribute.
Testable: Isolated responsibilities make it easier to write unit tests and reduce bugs.
Flexible: Adaptable to new requirements with minimal impact on existing code.

In essence, the SOLID principles are the cornerstone of writing clean, efficient, and sustainable Java code. They empower developers to build systems that are not only functional, but also scalable and easy to maintain in the long run.

How to find out the differences between 2 objects in Java (2023)

Rajesh Mishra — Mon, 07 Aug 2023 21:40:45 +0000

In this post, we will showcase a step-by-step guide on how to detect and present distinctions between two java objects by leveraging a set of classes and interfaces provided by Apache Commons Lang.

Classes, Interfaces, and pom.xml
The classes and interfaces to be used for this post are as follows:

org.apache.commons.lang3.builder.Diff
org.apache.commons.lang3.builder.DiffResult
org.apache.commons.lang3.builder.DiffBuilder
org.apache.commons.lang3.builder.Diffable

Scenario
We have two Employee Object for our use case, and we need to list the differences between them. The list must show the affected field and the old-new (from Employee 1 to Employee 2 values.

Employee Object 1
For the Employee Object, we have the following data.

Name = Ankit
ID = 1
Designation = Assistant Vice President
Address = Mumbai
Employee Object 2
For the Employee Object, we have the following data.

Name = Ankit
ID = 1
Designation = Vice President
Address = Pune

Read complete tutorial

How To Create Custom Annotation In Java

Rajesh Mishra — Sun, 18 Dec 2022 20:46:07 +0000

Create Custom Annotation:

In java, creating an annotation is @interface is used to create an Annotation.

public @interface MyAnnotation{

}

We can also define methods inside an annotation.

public @interface MyAnnotation{
   int value();
}

Note: The methods of an annotation should adhere to the following rules:

Method declaration should not have any parameters
Method declaration should not have any throws clause
Method return type should be of primitives, String, Class, Enum, Annotations, and Arrays of the preceding types

Also, we can provide a default value for the methods inside an annotation.

public @interface MyAnnotation{
   int value() default 1;
}

Types of Annotations:

Algorithm Code Complexity

Rajesh Mishra — Sun, 14 Aug 2022 17:07:21 +0000

Code Complexity compute it by using the control flow graph of the program. Cyclomatic complexity measures the number of nested conditions within the code, such as those created by for, if/else, switch, while, and until. The greater the number of conditions (as in example b from above), the greater the complexity.

Time complexity:
	Worst Case Scenario	Average Case Scenario	Best Case Scenario
Accessing an element	O(1)	O(1)	O(1)
Updating an element	O(1)	O(1)	O(1)
Deleting an element	O(n)	O(n)	O(1)
Inserting an element	O(n)	O(n)	O(1)
Searching for an element	O(n)	O(n)	O(1)

Algorithm complexity:
	Worst Case	Average Case	Best Case	Space Complexity
Quicksort	O(n2)	O(n log(n))	O(n log(n))	O(log(n))
Mergesort	O(n log(n))	O(n log(n))	O(n log(n))	O(n)
Heapsort	O(n log(n))	O(n log(n))	O(n log(n))	O(1)
Bubble Sort	O(n2)	O(n2)	O(n)	O(1)
Insertion Sort	O(n2)	O(n2)	O(n)	O(1)
Selection Sort	O(n2)	O(n2)	O(n2)	O(1)

Source: Java Algos

Java 8 Map vs flatmap method

Rajesh Mishra — Wed, 20 Jan 2021 10:09:44 +0000

Map vs FlatMap:

Java 8 stream API provides map() and flatMap() methods. Both these methods are intermediate methods and returns another stream as part of the output.

map() method use for transformation
flatMap() used for transformation & flattering
flatMap()-> map()+flatring

map():

map() takes Stream<T> as input and return Stream<R>
Stream<R> map (String<T> input)
it's mapper function produces single value for each input value. hence it also called as one-to-one mapping.

flatMap():

flatMap() takes Stream<Stream<T>> as input and return Stream<R>
Stream<R> map (String<T> input)
it's mapper function produces multiple value for each input value. hence it also called as one-to-many mapping.

map()	flatMap()
It processes stream of values.	It processes stream of stream of values.
It does only mapping.	It performs mapping as well as flattening.
It’s mapper function produces single value for each input value.	It’s mapper function produces multiple values for each input value.
It is a One-To-One mapping.	It is a One-To-Many mapping.
Data Transformation : From Stream to Stream	Data Transformation : From Stream<Stream to Stream
Use this method when the mapper function is producing a single value for each input value.	Use this method when the mapper function is producing multiple values for each input value.

Let's See the below example for better understanding

Employee.java

import java.util.List;

public class Employee {

    private int id;
    private String name;
    private String email;
    private List<String> mobileNumbers;

    public Customer() {
    }

    public Employee(int id, String name, String email, List<String> mobileNumbers) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.mobileNumbers = mobileNumbers;
    }

    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 getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public List<String> getMobileNumbers() {
        return mobileNumbers;
    }

    public void setMobileNumbers(List<String> mobileNumbers) {
        this.mobileNumbers = mobileNumbers;
    }
}

Repository.java

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

public class Repository {


    public static List<Employee> getAll() {
        return Stream.of(
                new Employee(001, "Nadeem", "Nadeem@localhost.com", Arrays.asList("737937955", "9812356")),
                new Employee(002, "Shyam", "Shyam@localhost.com", Arrays.asList("65563865", "987654")),
                new Employee(003, "Punneet", "Punneet@localhost.com", Arrays.asList("9412345", "43256")),
                new Employee(004, "Kailash", "Kailash@localhost.com", Arrays.asList("9812345678", "1234456546"))
        ).collect(Collectors.toList());
    }

}

MapFlatMapExample.java

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

public class MapFlatMapExample {
    public static void main(String[] args) {

        List<Employee> employee = Repository.getAll();

        List<String> emails = employee.stream()
                .map(employee -> employee.getEmail())
                .collect(Collectors.toList());
        System.out.println(emails);
        List<List<String>> mobileNumbers = customers.
                stream().map(employee -> employee.getMobileNumbers())
                .collect(Collectors.toList());
        System.out.println(mobileNumbers);

        List<String> mobiles = customers.stream()
                .flatMap(employee -> employee.getMobileNumbers().stream())
                .collect(Collectors.toList());
        System.out.println(mobiles);
    }
}

Output:

Nadeem@localhost.com,Shyam@localhost.com,Punneet@localhost.com,Kailash@localhost.com

737937955,9812356,65563865,987654,9412345,43256,9812345678,1234456546

String in java

Rajesh Mishra — Wed, 20 Jan 2021 09:48:47 +0000

What is String?

String Objects are immutable in nature

This one is a very important point for interview perspective. What does it mean when we say String is immutable. Immutability is – Once we assign some value to String, that value can never be changed.

String implements Serializable, Comparable and CharSequence interfaces.

We override compareTo(Object object) method in String class and define custom logic.

String overrides equals() and hashCode() methods.

This is another important point related to String, which makes String differ from StringBuffer. In String equals() and hashcode() is overridden and it has been defined custom logic inside equals() and hashcode(). Let’s see code snippet, how equals() and hashcode() is overridden.

String Constants Pool.

String works on String constant pool – String uses special memory location for reusability of String literals that is called String constant pool.

String Interview questions with examples:

String constant pool in Java
Why is String immutable in java
Comparing of two String using == and equals()
Important methods of String
How will we define an immutable class in java
How to create an immutable class with mutable object references in Java

String Constant Pool In Java with Example:

String uses a special memory location to reuse of String objects, is called String Constant Pool. Suppose we create a String object without new keyword i.e String s1 = “onlinetutorials” and again we do String s2 = “onlinetutorials” and String s3 = “onlinetutorials”. Here String will create only one object with value i.e "onlinetutorials". We will have three reference s1, s2, and s3 which are pointing the same object “onlinetutorials”.

How it works:

When first time we do String s1 = “onlinetutorials”, JVM will create a new object in String Constant Pool and s1 will refer to that object i.e “onlinetutorials”.
When we do the second time String s2 = “onlinetutorials”, JVM will check is there any object with value “onlinetutorials” already there in String Constant pool. As of now yes we have already “onlinetutorials” is there in String Constant pool, so it will not create a new object, just s2 reference variable will point to that existing “onlinetutorials” object. The same process will happen for String s3 = “onlinetutorials”.

Creating String object with new operator (How it works):

String str1 = new String(“onlinetutorials”);

Here the first JVM will check, is there any object available with the name “onlinetutorials” in String Constant Pool or not, if not it will create one object inside String Constant Pool and it will also create another object outside of String Constant Pool and str1 will point this object (the object which has been created outside of String Constant Pool).

public class StringExample {
    public static void main(String[] args) {

        String s1 = "OnlineTutorials";
        String s2 = s1 + "tech";
        s1.concat("technology");
        s2.concat(s1);
        s1 += "Java";
        System.out.println(s1 + "   " + s2);

    }
}

Immutable String in Java:

As we know String uses the string constant pool for the memory location. Suppose we have multiple reference variables, all are pointing to the same object, if String is not immutable and we change the value of any reference then all others reference will get affected.

Suppose now we are doing str1 = “onlinetutorials” and if String is not immutable, str2 and str3 will start pointing to “onlinetutorials”. As of now, we have three objects, it might possible we have a hundred or thousands of objects, all will start to point “onlinetutorials”. That’s the very big problem.

Since String is immutable, it is safe to use in multithreading. This avoids the use of synchronization for thread safety, String is implicitly thread safe in nature.

Comparing of two String using == and equals():

Before proceeding let’s see differences between == and equals(). == operator checks for references, if two different reference variable is pointing the same object == will return true, while equals() method is overridden in String class and it will check for actual content.

public class StringExample {
    public static void main(String[] args) {

        String s1 = "onlinetutorials";
        String s2 = "onlinetutorials";

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));

    }
}

Output:

true

Important methods of String:

public boolean equals(Object o)

This is a very frequently used method, which is overridden in String class. It checks for content, if the content is equal it returns true else it returns false. Let’s see a simple example –

public class StringEquals {
public static void main(String[] args) {

String s1 = new String("onlinetutorials");
String s2 = new String("onlinetutorials");

System.out.println(s1.equals(s2));

}
}

public boolean equalsIgnoreCase(String anotherString)

equalsIgnoreCase() will return true if all character in given String objects is the same, even an object contains the capital letters.

public class StringEqualsIgnore {
public static void main(String[] args) {

String s1 = "onlinetutorials";
String s2 = "ONLIETUTORIALS";

System.out.println(s1.equalsIgnoreCase(s2));

}
}

public String[] split(String regex)

split() method returns String array. We can split any string on the basis of some regex value like space, comma or hyphen(or other regex value).

public class StringSplit {
public static void main(String[] args) {

String str= "online tutorials tech";

String[] splitArray = str.split(" ");
for(String s: splitArray){
System.out.println(s);
}

}
}

How will we define an immutable class in java:

Define class as final.
Make fields as private and final.
Make the constructor private and create an instance within factory methods.
Initialize the field through the constructor.
Don’t define the setter method.
provide getter method for the corresponding fields.

final class ImmutableExample {
    private final String name;

    private ImmutableExample(String name) {
        this.name = name;
    }

    public static ImmutableExample getInstance() {
        return new ImmutableExample("ram");
    }

    public String getName() {
        return name;
    }

}

public class Test {
    public static void main(String[] args) {
        ImmutableExample m = ImmutableExample.getInstance();
        System.out.println("name  :-" + m.getName());

    }
}

you can also refer How to create an immutable class with mutable object references in Java

Sorting using Comparator in java with example

Rajesh Mishra — Mon, 16 Nov 2020 17:53:18 +0000

Table of Contents

Basic points about Comparator interface.
Example of sorting using Comparator in java using anonymous class.
Example of sorting using Comparator in java implementing Comparator interface.
Example of Sorting using Comparator and Java 8.
Soring list of an object using Comparator.comparing().

Basic points about Comparator interface.

Comparator is an interface available in java.util package, which provides multiple sorting(means we can sort the basis of id and name at the same time).

The Comparator interface contains compare(Object o1, Object o2) method which we can override and keep sorting logic there.

For sorting using Comparator interface we need to use Collections.sort(List list, Comparator c) method.

Different ways of sorting using Comparator interface.

Override compare() method.

@Override public int compare(Object o1, Object o2) {
 Employee e1 = (Employee) o1;
 Employee e2 = (Employee) o2;
 return e1.getName().compareTo(e2.getName());
}

Using Java 8 lambda expression.

Collections.sort(employeeList, (employee1, employee2) -> employee1.getName().compareTo(employee2.getName()));

Using Comparator.comparing().

employeeList.sort(Comparator.comparing(Employee::getId));

Example of sorting using Comparator in java using anonymous class.

In this example, we are going to sort Employee type of list on the basis of the name without implementing Comparator(Employee class will not implement Comparator).

import java.util.Collections;
import java.util.*;
class Employee {
 private String name;
 private int id;
 public Employee() {}
 public Employee(String name, int id) {
  super();
  this.name = name;
  this.id = 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;
 }
}
===============================================================
public class SortingUsingComparator {
 public static void main(String[] args) throws Exception {
  List emplist = new ArrayList < > ();
  emplist.add(new Employee("mohan", 5));
  emplist.add(new Employee("radhika", 1));
  emplist.add(new Employee("gopi", 3));
  emplist.add(new Employee("krishna", 2));
  System.out.println("sorting using comparator by name ------");
  Collections.sort(emplist, new Comparator() {
   @Override public int compare(Object o1, Object o2) {
    Employee e1 = (Employee) o1;
    Employee e2 = (Employee) o2;
    return e1.getName().compareTo(e2.getName());
   }
  });
  for (Employee e: emplist) {
   System.out.println(e.getId() + " " + e.getName());
  }
  System.out.println("sorting using comparator by id --------");
  Collections.sort(emplist, new Comparator() {
   @Override public int compare(Object o1, Object o2) {
    Employee e1 = (Employee) o1;
    Employee e2 = (Employee) o2;
    return e1.getId() - e2.getId();
   }
  });
  for (Employee e: emplist) {
   System.out.println(e.getId() + " " + e.getName());
  }
 }
}

sorting using comparator by name ——
3 gopi
2 krishna
5 mohan
1 radhika
sorting using comparator by id ——–
1 radhika
2 krishna
3 gopi
5 mohan

Example of sorting using Comparator in java implementing Comparator interface.

we can define a separate class which will implement Comparator interface.

import java.util.*;
import java.io.*;
class Employee {
 String name;
 int id;
 Employee(String name, int id) {
  this.name = name;
  this.id = id;
 }
}
class NameComparator implements Comparator {
 @Override public int compare(Object o1, Object o2) {
  Employee e1 = (Employee) o1;
  Employee e2 = (Employee) o2;
  return e1.name.compareTo(e2.name);
 }
}
class IdComparator implements Comparator {
 @Override public int compare(Object o1, Object o2) {
  Employee e1 = (Employee) o1;
  Employee e2 = (Employee) o2;
  return e2.id - e1.id;
 }
}
public class SortByUsingComparator {
 public static void main(String[] args) {
  List emplist = new ArrayList();
  emplist.add(new Employee("rakesh", 105));
  emplist.add(new Employee("bittu", 103));
  emplist.add(new Employee("tituu", 110));
  emplist.add(new Employee("asharaf", 108));
  System.out.println("sorting by name-------");
  Collections.sort(emplist, new NameComparator());
  Iterator itr = emplist.iterator();
  while (itr.hasNext()) {
   Employee emp = (Employee) itr.next();
   System.out.println(emp.name + " " + emp.id);
  }
  System.out.println("sorting by id---------");
  Collections.sort(emplist, new IdComparator());
  Iterator itr2 = emplist.iterator();
  while (itr2.hasNext()) {
   Employee emp = (Employee) itr2.next();
   System.out.println(emp.name + " " + emp.id);
  }
 }
}

The output of the above program is –
anjali 108
bittu 103
rakesh 105
shibha 110
sorting by id———
shibha 110
anjali 108
rakesh 105
bittu 103

Example of Sorting using Comparator and Java 8.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class Employee {
 private String name;
 private int id;
 Employee(String name, int id) {
  this.name = name;
  this.id = 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;
 }
}
public class SortingUsingJava8 {
 public static void main(String[] args) {
  List employeeList = new ArrayList();
  employeeList.add(new Employee("rakesh", 105));
  employeeList.add(new Employee("bittu", 103));
  employeeList.add(new Employee("shibha", 110));
  employeeList.add(new Employee("anjali", 108));
  System.out.println("sorting on basis of name-------");
  Collections.sort(employeeList, (employee1, employee2) -> employee1.getName().compareTo(employee2.getName()));// Lambda expression for sorting on basis of name
  for (Employee employee: employeeList) {
   System.out.println(employee.getName() + " " + employee.getId());
  }
  Lambda expression
  for sorting on basis of id System.out.println("sorting on basis of id-------");
  Collections.sort(employeeList, (employee1, employee2) -> employee1.getId() - employee2.getId());// Lambda expression for sorting on basis of id
  for (Employee employee: employeeList) {
   System.out.println(employee.getName() + " " + employee.getId());
  }
 }
}

The output of above program.
Sorting on basis of name——-
anjali 108
bittu 103
rakesh 105
shibha 110
Sorting on basis of id——-
bittu 103
rakesh 105
anjali 108
shibha 110

Soring list of an object using Comparator.comparing().

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
class Employee {
 private String name;
 private int id;
 Employee(String name, int id) {
  this.name = name;
  this.id = 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;
 }
}
public class SortingUsingJava8 {
 public static void main(String[] args) {
  List employeeList = new ArrayList();
  employeeList.add(new Employee("rakesh", 105));
  employeeList.add(new Employee("bittu", 103));
  employeeList.add(new Employee("shibha", 110));
  employeeList.add(new Employee("anjali", 108));
  System.out.println("sorting on basis of name-------");
  employeeList.sort(Comparator.comparing(Employee::getName));
  for (Employee employee: employeeList) {
   System.out.println(employee.getName() + " " + employee.getId());
  }
  System.out.println("sorting on basis of id-------");
  employeeList.sort(Comparator.comparing(Employee::getId));
  for (Employee employee: employeeList) {
   System.out.println(employee.getName() + " " + employee.getId());
  }
 }
}

The output of the above program. Sorting on basis of name: anjali 108 bittu 103 rakesh 105 shibha 110 Sorting on basis of id: bittu 103 rakesh 105 anjali 108 shibha 110

Learn more about collection in java

@PathVariable and @RequestParam annotations in Spring Boot Part 2

Rajesh Mishra — Mon, 16 Nov 2020 17:51:38 +0000

Table of Contents:

Basic points about @PathVariable and @RequestParam annotations.
@PathVariable annotations Example in Spring Boot.
@RequestParam example in Spring Boot.

Basic points about @PathVariable and @RequestParam annotations.

@PathVariable annotation-

This annotation introduced in Spring 3.0, available in org.springframework.web.bind.annotation package.
Optional elements ( name, required, value).
This annotation used as a method parameter.
It takes placeholder value from URI.
The example of rest URI when we use @PathVariable – http://localhost:9093/rest/listofbooks/{bookId}

@RequestaParam annotation-

This annotation introduced in Spring 2.5, available in org.springframework.web.bind.annotation package.
Optional elements (name, required, value).
This annotation used as a method parameter.
It takes parameter value from URI.
The example of rest URI when we use @RequestParam –

– http://localhost:9093/rest/listofbooks/{bookId}/book?bookName=book1

@PathVariable annotations Example in Spring Boot.

prerequisites –

JDK 1.8
Eclipse
maven
postman

Create maven project, Don’t forget to check ‘Create a simple project (skip)’click on next. Fill all details(GroupId – pathvariableexample, ArtifactId – pathvariableexample and name – pathvariableexample) and click on finish. Keep packaging as the jar.

POM.XML

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>pathvariableexample</groupId>
  <artifactId>pathvariableexample</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>pathvariableexample</name>  
  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
 </parent>
  <dependencies>
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
   </dependencies>
 </project>

Book.java

package com.onlintutorials.tech;

public class Book {
    int bookId;
    String bookName;
    String bookPrice;
    public int getBookId() {
        return bookId;
    }
    public void setBookId(int bookId) {
        this.bookId = bookId;
    }
    public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public String getBookPrice() {
        return bookPrice;
    }
    public void setBookPrice(String bookPrice) {
        this.bookPrice = bookPrice;
    }
    
}

BookController.java

package com.onlinetutotrials.tech;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;

@RestController
@RequestMapping(value = "/rest")
public class BookController {

    @RequestMapping(value = "/book/{bookId}",method = RequestMethod.GET)
    public Book getBookById(@PathVariable int bookId) {
        
        List<Book> listBook = createBook();
        for(Book book : listBook) {
            if(book.getBookId() == 1) {
                return book;
            }
        }
        
        return null;        
    }
    
    public List<Book> createBook() {
    Book book = new Book();
        book.setBookId(1);
        book.setBookName("book1");
        book.setBookPrice("100");
        
        Book book1 = new Book();
        book1.setBookId(2);
        book1.setBookName("book2");
        book1.setBookPrice("200");
        List<Book> bookList = new ArrayList<Book>();
        bookList.add(book);
        bookList.add(book1);
        
        return bookList;
        
    }
}

SpringMain.java

package com.onlinetutorials.tech;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SpringMain {
    public static void main(final String[] args) {
        final ConfigurableApplicationContext configurableApplicationContext = SpringApplication
                .run(SpringMain.class, args);
    }
}

Now hit the URL:

http://localhost:8080:/rest/book/1

@RequestParam example in Spring Boot.

Let’s modify the controller class.

BookController.java

package com.onlinetutorials.tech;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;

@RestController
@RequestMapping(value = "/rest")
public class BookController {

    @RequestMapping(value = "/listofbooks/{bookId}/book",method = RequestMethod.GET)
    public Book getBookById(
            @PathVariable int bookId, 
            @RequestParam String bookName) {
        
        List<Book> listBook = createBook();
        for(Book book : listBook) {
            System.out.println("bookIs is ---"+bookId);
            System.out.println("bookName is ---"+bookName);
            if(book.getBookId() == 1 && book.getBookName().equals(bookName)) {
                return book;
            }
        }
        return null;
    }
    
    public List<Book> createBook() {
        
        Book book = new Book();
        book.setBookId(1);
        book.setBookName("book1");
        book.setBookPrice("100");
        
        Book book1 = new Book();
        book1.setBookId(2);
        book1.setBookName("book2");
        book1.setBookPrice("200");
        List<Book> bookList = new ArrayList<Book>();
        bookList.add(book);
        bookList.add(book1);
        
        return bookList;
        
    }
}

Now hit the URL to see the OutPut:

http://localhost:8080:/rest/listpfbooks/1/book?bookName=book1

Source: Java Algos

Exception Handling in Java

Rajesh Mishra — Fri, 07 Aug 2020 16:44:34 +0000

Exception
Checked and Unchecked Exception in java
1. Checked Exception
2. UnChecked Exception
Difference between checked and unchecked exception in java
Try Catch and finally block
1. Try with finally block
Custom exception in Java With Example
Try with multiple catch blocks in java with example
Return statement in exception handling in Java with Example
Exception in case of method overriding

Exception in java

An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program’s executions.

Checked and Unchecked Exception

All the Exceptions which are not a child class of RuntimeException are called Checked Exception. We have to handle all Checked exception at compile time by using throws keywords or by using try-catch block

Examples of Checked Exception.

IOException
FileNotFoundException
ClassNotFoundException
CloneNotSupportedException
NoSuchMethodException
InterruptedException
NoSuchFieldException
ParseException

import java.io.*;
class Exception { 
public static void main(String args[]) {
    FileInputStream fis = new FileInputStream("C:/Onlinetutorials"); 
    fis.close();
  }
}

The above code will not compile because FileInputStream constructor defined public FileInputStream(String name) throws FileNotFoundException which is checked exception and also close() method throws IOException which is also a checked exception. We need to do following changes in order to resolve the compilation error.

As we know checked exception must be handle at compile time either by using throws keyword or by using a try-catch block. So here firstly we are using throws keyword.

Using throws keyword:

import java.io.*;
class Exception { 
public static void main(String args[]) throws Exception {
    FileInputStream fis = new FileInputStream("C:/Onlinetutorials"); 
    fis.close();
  }
}

Using try catch block:

import java.io.*;
class Exception { 
public static void main(String args[]) {
try {
    FileInputStream fis = new FileInputStream("C:/Onlinetutorials"); 
    fis.close();
}catch (Exception e) {
    e.printStackTrace();
    }
  }
}

Unchecked Exception

All Exceptions which are the subclass of RuntimeException is called unchecked exceptions. Like Checked exceptions, it is not mandatory to handle RuntimeExcepton by using throws keyword or try-catch block. If we do some programming mistakes then JVM will automatically throw a runtime exception. It will always happen at runtime.

Example of UnChecked Exception.

NullPointerException
ClassCastException
ArrayIndexOutOfBoundsException
IllegalStateException
NumberFormatException
IllegalArgumentException
IllegalMonitorStateException
IndexOutOfBoundsException

Let’s see an example that throws NullPointerException.

class NullPointerExample{ 
    public static void main(String args[]) {
    String s=null;
    System.out.println(s.hashCode());
  }
}

Difference between checked and unchecked exception in java

Checked Exception
UnChecked Exception

The Exception which are not subclass of RuntimeException are Checked Exception.
This occuured only at runtime.

The Checked Exception must need to be handled at compile time either by using try catch or throws keyword
This is not mandatory to handle.

Example is :FileNotFoundException/SQLException
Example is :NullPointerException

Try Catch and finally block

The catch block will execute only in case if we have some exception in the try block. The finally block will get always executed.

public class ExceptionHandling{
public static void main(String[] args) {
    try{
               //Custom logic
    }catch(Exception e){
        // if some exception will come inside try block 
        //then only catch block will execute    
    }finally {
        //it will execute always even exception comes inside try block or not
    }
}
}

Try finally block

public class TryWithFinally{
public static void main(String[] args) {
    try{        
        String stringVariable = "OnlineTutorials";
        System.out.println("value of stringVariable "+stringVariable);      
    }finally {
        System.out.println("finally block executed");       
    }
}
}

Note – Finally block mainly used to perform release of resources clean up or session closing or database connection closing task.

Creating a custom exception in Java With Example

Custom Exception: Class created by extending Exception class or RuntimeException class is known as CustomException.

Steps to Create custom exception.

Create CustomException class(Mainly is application name) extending Exception or RuntimeException class.
Define one or two or more parametrized constructor.
In each constructor, Define super.
Use throw keyword to show the proper exception message.

package com.onlinetutorials.tech;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class OnlineTutorialsException extends Exception{
        public OnlineTutorialsException (String message) {
            super(message);
        }
        public OnlineTutorialsException (String message, Throwable t) {
            super(message, t);
        }
           public static void main(String[] args) {
        try {
           String customerId= null;
                   if(customerId== null) {
                throw new OnlineTutorialsException("Customer Id Cannot be null ");
               }
        }catch(Exception e) {
            System.err.print(e.printStackTrace());
        }
            
       }
}

Output is – com.onlinetutorials.tech.OnlineTutorialsException: Customer Id Cannot be null at com.onlinetutorials.tech.OnlineTutorialsException.main(OnlineTutorialsException .java:20)

Creating a custom exception extending RuntimeException class

package com.onlinetutorials.tech;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class CustomException extends RuntimeException{
     public CustomException (String message) {
            super(message);
        }
     public CustomException (String message, Throwable t) {
            super(message, t);
     }
    public static void main(String[] args) {        
        String dateAsString = "11101988";       
        DateFormat dateFormat = new SimpleDateFormat("dd-MMM-yyyy");        
        try {
            Date date = dateFormat.parse(dateAsString);
        }catch(Exception e) {
            throw new CustomException("problem in parsing the date");
        }                           
    }
}

Output is – Exception in thread “main” com.onlinetutorials.tech.CustomException: problem in parsing the date at com.onlinetutorials.tech.CustomException.main(CustomException.java:27)

Try with multiple catch blocks in java with example

How to implement try with multiple catch blocks in java.
What is the benefit of multiple catch blocks? How to implement in the real-time scenario?

package com.onlinetutorials.tech;

public class TryWithMultipleCatch{
public static void main(String[] args) {
    try {
    //Custom logic
    }catch(NullPointerException n) {
        System.err.println(n);
    }catch(RuntimeException r) {
        System.err.println(r);
    }catch(Exception e) {
        System.err.println(e);
    }
}
}

Return statement in exception handling in Java with Example

package com.onlinetutorials.tech;

public class Example {
public static void main(String[] args) {
    try{        
        return;
        
    }catch(NullPointerException e) {
        System.err.println("catch block");
    }
    
}
}

package com.onlinetutorials.tech;

public class Example2 {
public static void main(String[] args) {
    try{        
        return;
    }catch(NullPointerException e) {
        return;
    }finally {
        return;
    }       
}
}

Exception in case of method overriding

when the superclass method throws some exception.

Subclass overridden method can declare subclass exception or same exception(i.e declares in superclass) or no exception.

import java.io.FileNotFoundException;
import java.io.IOException;
class Vehicle{
    public void m1() throws IOException{
    System.out.println("super class method");
  }
}
class Car extends Vehicle{
    // subclass exception
    public void m1() throws FileNotFoundException{
    System.out.println("sub class method");
  }
}
public class Test4 {
    public static void main(String[] args) throws Exception{
    Vehicle vehicle=new Car();
    vehicle.m1();
  }
}

Source: Exception Handling in Java

Sorting using Comparable in java with example

Rajesh Mishra — Sat, 04 Jul 2020 16:30:37 +0000

Table of Contents

Basic points about the comparable interface.
Program to sort on the basis of the name using Comparable.
Program to sort on the basis of the id using Comparable.

Basic points about the comparable interface.

Comparable is an interface available in java.lang package, which provides single sorting(means we can sort either the basis of id or name at a time. Consider we have Employee class which contains fields name and id).

The Comparable interface contains compare() method. If we want to sort any collection of user-defined objects using comparable, our java class must need to implement Comparable interface and override compareTo(Object o) method.

Program to sort on the basis of the name using Comparable.

Define an Employee class which should implement Comparable interface and create two variables name and id. Provide corresponding getter/setter and parameterized constructor. Here we are going to sort employee object on basis of Id.
Override compareTo () method and provide logic.

@Override
public int compareTo(Object o) {
        Employee employee = (Employee) o;
        String name = employee.name;
        return this.name.compareTo(name);
}

Override compareTo () method and provide logic.
Create a couple of employee object using parameterized constructor and add into list.

List emplist = new ArrayList();
emplist.add(new Employee("John", 101));
emplist.add(new Employee("Eric", 106));
emplist.add(new Employee("Arya", 103));
emplist.add(new Employee("Sansa", 105));
emplist.add(new Employee("Cersei", 102));

Use Collections.sort(emplist) the method which will internally call the compareTo() method(Check here how String compareTo() method internally works in java). Here Collections is a class and sort() is a static method. Use Java 8 forEach() method and print the name and id.

Comparable example in java:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class Employee implements Comparable {
 private String name;
 private int id;
 public Employee(String string, int i) {
  this.name = string;
  this.id = i;
 }
 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 int compareTo(Object o) {
  Employee employee = (Employee) o;
  String name = employee.name;
  return this.name.compareTo(name);
 }
}
public class SortingByNameUsingComprable {
 public static void main(String[] args) {
  List emplist = new ArrayList();
  emplist.add(new Employee("John", 101));
  emplist.add(new Employee("Eric", 106));
  emplist.add(new Employee("Arya", 103));
  emplist.add(new Employee("Sansa", 105));
  emplist.add(new Employee("Cersei", 102));
  Collections.sort(emplist);
  emplist.forEach(empolyee -> 
          System.out.println(empolyee.getName() + " " + empolyee.getId()));
 }
}

Arya 103
Cersei 102
Eric 106
John 101
Sansa 105

Program to sort on the basis of the id using Comparable.

For sorting on basis of id we need to change compareTo() logic as below. The rest of the steps would be the same.

@Override public int compareTo(Object o) {
 Employee employee = (Employee) o;
 return this.getId() - employee.getId();
}

import java.lang.reflect.Field;
import java.util.*;
 
class Employee implements Comparable {
    String name;
    int id;
 
    public Employee(String string, int i) {
        this.name = string;
        this.id = i;
    }
 
    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 int compareTo(Object o) {
        Employee employee = (Employee) o;
        return this.getId() - employee.getId();
 
    }
}
 
public class SortingByIdUsingComprable {
    public static void main(String[] args) {
        List emplist = new ArrayList();
        emplist.add(new Employee("John", 101));
        emplist.add(new Employee("Eric", 106));
        emplist.add(new Employee("Arya", 103));
        emplist.add(new Employee("Sansa", 105));
        emplist.add(new Employee("Cersei", 102));
 
        Collections.sort(emplist);
        emplist.forEach(empolyee -> System.out.println(empolyee.getName() + "   " + empolyee.getId()));
    }
}

John 101
Cersei 102
Arya 103
Sansa 105
Eric 106

Learn more about collection in java