DEV Community: Ezhil Abinaya K

@GetMapping Annotation in Spring Boot

Ezhil Abinaya K — Wed, 07 Oct 2026 07:00:27 +0000

In Spring Boot, @GetMapping is annotations used to handle HTTP requests in Spring MVC controllers. They help map specific HTTP methods to controller methods when building REST APIs.@GetMapping is used to retrieve data from the server.
GetMapping annotation
@GetMapping in Spring is used to handle HTTP GET requests in RESTful web services. It maps a specific URL to a controller method that retrieves data from the server.

Used to retrieve or read data from the server.
Parameters are usually passed through URL path variables or query parameters.

@GetMapping("/students")
public List<Student> getAllStudents() {
 return studentRepository.findAll();
}

getAllStudents method is annotated with @GetMapping annotation. This means that getAllStudents method will be called when an HTTP Get request is received at the /students URL.
Reference
https://www.geeksforgeeks.org/advance-java/spring-postmapping-and-getmapping-annotation/

FileReader in Java

Ezhil Abinaya K — Tue, 06 Oct 2026 07:54:41 +0000

FileReader
The FileReader class in Java is used to read data from a file in the form of characters. It is a character-oriented stream that makes it ideal for reading text files.
There are several ways to read files.

Scanner - best for simple text and when you want to parse numbers or words easily.
BufferedReader - best for large text files, because it is faster and reads line by line.
FileInputStream - best for binary data (images, audio, PDFs) or when you need full control of raw bytes.

Constructors of Java FileReader Class
1. FileReader(String fileName)
Creates a new FileReader object to read data from a file with the given name.

FileReader fr = new FileReader("example.txt");

2. FileReader(File file)
Creates a new FileReader object to read from the specified File object.

File file = new File("example.txt");
FileReader fr = new FileReader(file);

Hierarchy of the FileReader class.

References
https://www.geeksforgeeks.org/java/java-io-filereader-class/
https://www.w3schools.com/JAVA/java_files_read.asp

Spring Boot

Ezhil Abinaya K — Mon, 05 Oct 2026 06:54:00 +0000

Spring Boot is a Java framework built on Spring that simplifies application development with auto-configuration, embedded servers, and minimal boilerplate code. It helps developers build production-ready applications for web, REST APIs, microservices, security, and cloud deployment.
REST API Development
Spring Boot simplifies the creation of REST APIs using annotations and minimal configuration.
REST services exchange data in formats such as JSON and XML, with JSON being the most widely used format.
REST
REST (Representational State Transfer) is an architectural style used for designing network-based applications. It allows different systems to communicate over HTTP using standard methods such as GET, POST, PUT, and DELETE.

Introduced by Roy Thomas Fielding to simplify web communication using HTTP protocols.
Widely used for building scalable and stateless web APIs in frameworks like Spring Boot.

REST Controller
A REST Controller in Spring Boot is a class annotated with @RestController that processes incoming HTTP requests and returns data objects rather than views.

It combines the functionality of @Controller and @ResponseBody.
It is primarily used for building RESTful APIs.
The response is automatically converted to JSON or XML using message converters.

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Welcome to REST API!";
    }
}

@RestController tells Spring that this class will handle REST API requests.
@GetMapping("/hello") maps the HTTP GET request to the method.
The method returns a String, which Spring sends directly to the client as the response.

References
https://www.geeksforgeeks.org/advance-java/spring-rest-controller/
https://www.geeksforgeeks.org/springboot/spring-boot-introduction-to-restful-web-services/
https://www.geeksforgeeks.org/springboot/introduction-to-spring-boot/

Comparable and Comparator in Java

Ezhil Abinaya K — Mon, 05 Oct 2026 06:38:53 +0000

Mobile.java

package com.payilagam.collections;

public class Mobile implements Comparable<Mobile> {

    private String brand;
    private int price;
    private int ram;

    public Mobile(String brand, int price, int ram) {
        super();
        this.brand = brand;
        this.price = price;
        this.ram = ram;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public int getRam() {
        return ram;
    }
    public void setRam(int ram) {
        this.ram = ram;
    }
    @Override
    public String toString() {
        return "Mobile [brand=" + brand + ", price=" + price + ", ram=" + ram + "]";
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public int compareTo(Mobile mobile) {
        return this.ram - mobile.ram;
    }

}

Main.java

package com.payilagam.collections;

import java.util.ArrayList;
import java.util.Collections;

public class Main {

    public static void main(String[] args) {
        ArrayList<Mobile> shop = new ArrayList<>();
        shop.add(new Mobile("vivo",15000,6));
        shop.add(new Mobile("realme",20000,8));
        shop.add(new Mobile("oppo",25000,8));
        Collections.sort(shop);
        System.out.println(shop);









//      marks.add(89);
//      marks.add(90);
//      marks.add(78);
//      marks.add(99);
//      
//    Comparelogic logic = new Comparelogic();
//    Collections.sort(marks,logic);
//    System.out.println(marks);

    }

}

Comparelogic.java

package com.payilagam.collections;

import java.util.Comparator;

public class Comparelogic implements Comparator<Integer> {

    @Override
    public int compare(Integer o1, Integer o2) {

        return o1 - o2;
    }

}

[Mobile [brand=vivo, price=15000, ram=6], Mobile [brand=realme, price=20000, ram=8], Mobile [brand=oppo, price=25000, ram=8]]

Maven

Ezhil Abinaya K — Sun, 04 Oct 2026 13:44:15 +0000

Maven
Maven is a build automation tool developed in Java, mainly used to manage and streamline the build process of Java-based applications. It simplifies tasks like compilation, testing, and packaging through a centralized configuration.

Uses a POM (Project Object Model) to manage project structure and dependencies
Automates tasks like compilation, testing, and packaging
Maintains all project configurations in a single pom.xml file

Maven Project Structure

src/main/java: It contains the main Java source code.
src/main/resources: It contains non-Java resources used by the application.
src/main/webapp: It contains resources for web applications.
src/test/java: It contains test source code.
src/test/resources: It contains resources used for testing.
target: It contains compiled classes, packaged JARs/WARs, and other built artifacts.
pom.xml: The Project Object Model file that defines the project configuration, dependencies, and build settings.

Collections.sort() in Java

Ezhil Abinaya K — Fri, 02 Oct 2026 08:14:06 +0000

Collections.sort()
The Collections.sort() method in Java is used to sort elements of a List in ascending order. It is part of the java.util.Collections class and works with List implementations like ArrayList and LinkedList. It simplifies sorting by providing a built-in mechanism.

Sorts elements based on natural ordering or custom Comparator
Works with List implementations, not arrays
Modifies the list in-place without creating a new list

Example: Sorting an ArrayList in ascending order

import java.util.*; 

public class Collectionsorting 
{ 
    public static void main(String[] args) 
    { 
        // Create a list of strings 
        ArrayList<String> al = new ArrayList<String>(); 
        al.add("Geeks For Geeks"); 
        al.add("Friends"); 
        al.add("Dear"); 
        al.add("Is"); 
        al.add("Superb"); 

        /* Collections.sort method is sorting the 
        elements of ArrayList in ascending order. */
        Collections.sort(al); 

        // Let us print the sorted list 
        System.out.println("List after the use of" + 
                        " Collection.sort() :\n" + al); 
    } 
}
//List after the use of Collection.sort() :
[Dear, Friends, Geeks For Geeks, Is, Superb]

Custom Sorting
Sorting an ArrayList according to user defined criteria. We can use Comparator Interface for this purpose.

References
https://www.geeksforgeeks.org/java/collections-sort-java-examples/

Abstract in Java

Ezhil Abinaya K — Wed, 30 Sep 2026 07:26:32 +0000

Abstraction
Abstraction in Java is the process of hiding implementation details and exposing only the essential functionality of an object. It focuses on what an object does rather than how it performs the operation.
Real-Life Example : A vehicle is a simple real-life example of abstraction. Different types of vehicles can start in different ways, but the common operation can be defined without exposing its implementation details.
Abstract class
An abstract class is a class declared using the abstract keyword that cannot be instantiated directly. It can contain both abstract methods (without a body) and concrete methods (with a body), allowing it to provide common functionality while leaving some behavior to subclasses.

// Abstract class
abstract class Animal {
  // Abstract method (does not have a body)
  public abstract void animalSound();
  // Regular method
  public void sleep() {
    System.out.println("Zzz");
  }
}

// Subclass (inherit from Animal)
class Pig extends Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

// Abstract class
abstract class Animal {
  // Abstract method (does not have a body)
  public abstract void animalSound();
  // Regular method
  public void sleep() {
    System.out.println("Zzz");
  }
}

// Subclass (inherit from Animal)
class Pig extends Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}
// Abstract class
abstract class Animal {
  // Abstract method (does not have a body)
  public abstract void animalSound();
  // Regular method
  public void sleep() {
    System.out.println("Zzz");
  }
}

// Subclass (inherit from Animal)
class Pig extends Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

//The pig says: wee wee
Zzz

References
https://www.w3schools.com/java/java_abstract.asp
https://www.geeksforgeeks.org/java/abstraction-in-java-2/

Exception Handling in Java

Ezhil Abinaya K — Tue, 29 Sep 2026 13:39:41 +0000

Exception
An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.
When an error occurs within a method, the method creates an object and hands it off to the runtime system. The object, called an exception object, contains information about the error, including its type and the state of the program when the error occurred. Creating an exception object and handing it to the runtime system is called throwing an exception.

Exception Handling
Exception handling in Java is a mechanism used to handle exceptional conditions that occur during program execution. It helps prevent the program from terminating unexpectedly and allows developers to provide appropriate recovery or error-handling logic.

Separates error-handling code from normal program logic.
Helps maintain the normal flow of program execution.
Supports handling of both checked and unchecked exceptions.

Types of Exception
1. Built-in Exception
Built-in Exception are pre-defined exception classes provided by Java to handle common errors during program execution. There are two type of built-in exception in java.

Checked Exception: These exceptions are checked at compile time, forcing the programmer to handle them explicitly.
Unchecked Exception: These exceptions are checked at runtime and do not require explicit handling at compile time.

2. User-Defined Exception
Sometimes, the built-in exceptions in Java are not able to describe a certain situation. In such cases, users can also create exceptions, which are called "user-defined Exceptions".

The try block contains code that might throw an exception,
The catch block handles the exception if it occurs.

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

        int n = 10;
        int m = 0;

        try {
            int ans = n / m;
            System.out.println("Answer: " + ans);
        } catch (ArithmeticException e){
            System.out.println("Error: Division by 0!");
        } 
    }
}
//Error: Division by 0!

throw and throws Keywords

The throw keyword is used to create a custom error. The throw statement is used together with an exception type. There are many exception types available in Java: ArithmeticException, ClassNotFoundException, ArrayIndexOutOfBoundsException, SecurityException, etc.
The throws keyword indicates what exception type may be thrown by a method.There are many exception types available in Java: ArithmeticException, ClassNotFoundException, ArrayIndexOutOfBoundsException, SecurityException, etc.

public class Main {
  static void checkAge(int age) { 
    if (age < 18) {
      throw new ArithmeticException("Access denied - You must be at least 18 years old."); 
    } else {
      System.out.println("Access granted - You are old enough!"); 
    }
 } 

 public static void main(String[] args) { 
   checkAge(15); 
 } 
}
//Exception in thread "main" java.lang.ArithmeticException: Access denied - You must be at least 18 years old.
    at Main.checkAge(Main.java:4)
    at Main.main(Main.java:11)

  checkAge(22); 
//Access granted - You are old enough!

throws

public class Main {
  static void checkAge(int age) throws ArithmeticException { 
    if (age < 18) {
      throw new ArithmeticException("Access denied - You must be at least 18 years old."); 
    } else {
      System.out.println("Access granted - You are old enough!"); 
    }
 } 

 public static void main(String[] args) { 
   checkAge(15); 
 } 
}

finallly
The finally keyword is used to execute code (used with exceptions - try..catch statements) no matter if there is an exception or not.

public class Main {
  public static void main(String[] args) {
    try {
      int[] myNumbers = {1, 2, 3};
      System.out.println(myNumbers[10]);
    } catch (Exception e) {
      System.out.println("Something went wrong.");
    } finally {
      System.out.println("The 'try catch' is finished.");
    }
  }
}
//Something went wrong.
The 'try catch' is finished.

References
https://docs.oracle.com/javase/tutorial/essential/exceptions/definition.html
https://www.geeksforgeeks.org/java/throw-throws-java/
https://www.w3schools.com/java/ref_keyword_finally.asp
https://www.geeksforgeeks.org/java/exceptions-in-java/

Java Collections Framework

Ezhil Abinaya K — Mon, 28 Sep 2026 10:41:02 +0000

Java Collections Framework (JCF) is a set of classes and interfaces that provide ready-made data structures to store and manipulate groups of objects efficiently.Java provides collection interfaces like List, Set, Map, and Queue, with ready-made classes such as ArrayList, HashSet, HashMap, and PriorityQueue, so you don’t have to write data-handling code from scratch.The Collection Framework improves productivity by making code more reusable, maintainable and faster to develop.
List
The List interface is part of the Java Collections Framework and represents an ordered collection of elements.You can access elements by their index, add duplicates, and maintain the insertion order.Since List is an interface, you cannot create a List object directly.Instead, you use a class that implements the List interface, such as:

ArrayList - like a resizable array with fast random access
LinkedList - like a train of cars you can easily attach or remove Note: Use List when you care about order, you may have duplicates, and want to access elements by index. List vs Array Common List Methods
add() --> adds an element to the end of the list.

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    ArrayList<String> cars = new ArrayList<String>();
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");
    cars.add("Mazda");
    System.out.println(cars); //[Volvo, BMW, Ford, Mazda]
  }
}

get()-->returns an element at the specified position.

System.out.println(cars.get(0));//volvo

set()-->replaces the element at the specified position.

 cars.set(0, "Opel");
    System.out.println(cars);//[Opel, BMW, Ford, Mazda]

remove--> remove an element at the specified position.

 cars.remove(0);
    System.out.println(cars);//[BMW, Ford, Mazda]

size()-->returns the number of elements in the list.

import java.util.ArrayList;

public class Main { 
  public static void main(String[] args) { 
    ArrayList<String> cars = new ArrayList<String>();
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");
    cars.add("Mazda");
    System.out.println(cars.size());//4
  } 
}

References
https://www.w3schools.com/java/java_list.asp
https://www.geeksforgeeks.org/java/java-collection-tutorial/
https://www.geeksforgeeks.org/java/list-add-method-in-java-with-examples/
https://www.w3schools.com/java/java_ref_arraylist.asp

StringBuffer in Java

Ezhil Abinaya K — Thu, 24 Sep 2026 06:45:37 +0000

StringBuffer
StringBuffer class in Java represents a sequence of characters that can be modified, which means we can change the content of the StringBuffer without creating a new object every time. It represents a mutable sequence of characters.
append(char c)
It appends the string representation of the char argument to this sequence.

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

        // Creating StringBuffer
        StringBuffer s = new StringBuffer();

        // Adding elements in StringBuffer
        s.append("Hello");
        s.append(" ");
        s.append("world");

        // String with the StringBuffer value
        String str = s.toString();
        System.out.println(str);
    }
}
//Hello world

insert() Method
insert() method inserts the given string with this string at the given position.

 s.insert(1, "Java");
 System.out.println(s); // HJavaello world

replace()
replace() method replaces the given string from the specified beginIndex and endIndex-1.

   StringBuffer sb = new StringBuffer("Hello");
        sb.replace(1, 3, "i"); 
        System.out.println(sb);
//Hilo

delete()
delete() method is used to delete the string from the specified beginIndex to endIndex-1.

sb.delete(1, 3);
 System.out.println(sb);//Ho

reverse()
reverse() method of the StringBuffer class reverses the current string.

sb.reverse();
 System.out.println(sb);//oH

Reference
https://www.geeksforgeeks.org/java/stringbuffer-class-in-java/
https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html

String Methods in Java

Ezhil Abinaya K — Wed, 23 Sep 2026 05:02:42 +0000

charAt()
The charAt() method returns the character at the specified index in a string.The index of the first character is 0, the second character is 1, and so on.It throws IndexOutOfBoundsException - if index is negative or not less than the length of the specified string.
Syntax

public char charAt(int index)

public class Main {
  public static void main(String[] args) {
    String myStr = "Hello";
    char result = myStr.charAt(0);
    System.out.println(result);
  }
}
// H

concat()
concat(String str)
It Concatenates the specified string to the end of this string.It returns a String, representing the text of the combined strings.

String firstName = "John ";
String lastName = "Doe";
System.out.println(firstName.concat(lastName));
//John Doe

contains
(CharSequence s)
The contains() method checks whether a string contains a sequence of characters.It returns true if the characters exist and false if not. It throws NullPointerException - if the returned value is null.It return type is boolean.

String myStr = "Hello";
System.out.println(myStr.contains("Hel"));   // true
System.out.println(myStr.contains("e"));     // true
System.out.println(myStr.contains("Hi"));    // false

isEmpty()
The isEmpty() method checks whether a string is empty or not. It returns true if, and only if, length() is 0.It return data type is boolean.

String myStr1 = "Hello";
String myStr2 = "";
System.out.println(myStr1.isEmpty());
System.out.println(myStr2.isEmpty());
//false
true

length()
It returns the length of this string.It returns value is int.

String txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
System.out.println(txt.length());
//26

equals(Object anObject)
It Compares this string to the specified object.compares two strings, and returns true if the strings are equal, and false if not.
anObject = An Object, representing the other string to be compared

String myStr1 = "Hello";
String myStr2 = "Hello";
String myStr3 = "Another String";
System.out.println(myStr1.equals(myStr2)); // Returns true because they are equal
System.out.println(myStr1.equals(myStr3)); // false

replace(char oldChar, char newChar)
The replace() method searches a string for a specified character, and returns a new string where the specified character(s) are replaced.

String myStr = "Hello";
System.out.println(myStr.replace('l', 'p'));
//Heppo

split(String regex)
It splits this string around matches of the given regular expression. it returns String[].
regex= Required. A regular expression defining the separators where the string is split.

String myStr = "Split a string by spaces, and also punctuation.";
String regex = "[,\\.\\s]";
String[] myArray = myStr.split(regex);
for (String s : myArray) {
  System.out.println(s);
}
//Split
a
string
by
spaces

and
also
punctuation

References
https://www.w3schools.com/java/ref_string_split.asp
https://docs.oracle.com/javase/8/docs/api/java/lang/String.html

My First Tech Talk at Kanchi Linux Users Group

Ezhil Abinaya K — Sun, 20 Sep 2026 12:55:41 +0000

I’m happy to share that I recently had the opportunity to give my first tech talk as a speaker.Preparing for the talk itself taught me a lot about structuring content, communicating clearly, and speaking with confidence.A small technical issue meant that my slides were not visible in the recording, but the experience of delivering the talk was truly valuable. 😊

Thank you to everyone who gave me this opportunity and supported me. [(https://www.youtube.com/live/wapddlEulUA?si=PXIrSqQgySammkEP)]