DEV Community: Bharath S R

🔋 10 Hidden Android Battery-Saving Tricks You Probably Don’t Know About

Bharath S R — Fri, 14 Nov 2025 11:03:35 +0000

Boost battery life without uninstalling apps or turning your phone into a brick.

Most Android phones come with powerful hardware and bright displays, but battery life often suffers because of background activity, hidden settings, and unnecessary system processes. The good news? Android has a lot of lesser-known battery-saving features that can dramatically extend your usage—if you know where to look.

In this post, we’ll cover 10 hidden tricks that can add hours to your battery life.

1. Restrict Background Battery Usage

Many apps continue running even when you’re not using them, quietly eating up battery.

How to enable:

Go to Settings → Battery → Battery usage

Tap a high-drain app

Select Restricted or Optimize

This prevents apps from waking up unnecessarily.

Best for: Social apps, shopping apps, food delivery apps, and games.

2. Turn On Adaptive Battery

Android’s built-in AI learns your app habits. Apps you rarely open get limited access to your battery.

How to enable:

Settings → Battery → Adaptive Battery

This alone can increase battery life by up to 10–20% over time.

3. Disable Wi-Fi & Bluetooth Scanning

Even when you toggle Wi-Fi or Bluetooth OFF, your phone may still scan for networks and devices in the background.

How to disable:

Settings → Location → Location services

Turn off Wi-Fi scanning

Turn off Bluetooth scanning

It stops unnecessary background activity—especially useful outdoors.

4. Turn Off “Mobile Data Always Active”

Your phone keeps mobile data active even when you’re connected to Wi-Fi, draining battery through constant signal switching.

How to disable:

Open Developer Options

Search for Mobile data always active

Turn it OFF

Note: You must enable Developer Options first (tap Build Number 7 times).

5. Limit Background Processes (Advanced Trick)

This reduces how many apps Android keeps alive in memory.

How to enable:

Developer Options → Background process limit

Choose “At most 2 processes” for maximum savings

Or leave at “Standard” for normal performance

This trick stops rogue apps from silently starting again.

6. Disable Auto-Start for Certain Apps

Brands like Xiaomi, Vivo, Oppo, and OnePlus allow apps to automatically launch themselves at startup.

How to disable:

Settings → Apps → Auto-start / Auto-launch

Turn OFF apps you don’t need running 24/7

Great for cutting down on background clutter.

7. Reduce Screen Refresh Rate

A 120Hz or 144Hz display looks smooth—but drains a lot of battery.

How to change:

Settings → Display → Motion smoothness / Refresh rate

Switch to 60Hz when battery-saving is a priority

This can add HOURS of extra screen time on AMOLED displays.

8. Use Ultra Battery Saving Mode in Emergencies

Most Android phones have a hidden “ultra power-saver” mode that disables background syncing and unnecessary features.

How to enable:

Settings → Battery → Power Saving Mode

Look for “Ultra,” “Extreme,” or “Super” power saving

This mode can stretch 10% battery to last several hours.

9. Reduce Vibration & Haptic Feedback

Vibration motor = power-hungry hardware.

How to reduce:

Settings → Sound & vibration

Reduce intensity or turn off:

Keyboard vibration

Touch vibration

Notification vibration

You’ll still get the essentials while saving battery.

10. Disable “Hey Google” Voice Detection

Your microphone is always listening for the hotword, constantly draining resources.

How to disable:

Settings → Google → Search → Voice → Voice Match

Turn off “Hey Google”

You can still activate Google Assistant manually.

🔋 Final Thoughts

These 10 hidden Android battery-saving tricks aren’t the typical “turn down your brightness” advice—these are under-the-hood optimizations that actually work.

By tweaking these settings, you can:
✔ Add extra hours of screen time
✔ Reduce background drain
✔ Improve overall performance

There’s an AI for That: A Practical Guide to Smarter Work

Bharath S R — Tue, 23 Sep 2025 04:43:24 +0000

Artificial Intelligence (AI) is no longer confined to research labs or big tech companies. Today, it’s shaping how we write, design, learn, and even make business decisions. With thousands of tools emerging every year, the phrase “there’s an AI for that” is becoming a reality.

But how do we separate the hype from the truly useful? Let’s break it down.

1. Where AI is Already Adding Value

Here are five categories where AI tools are making a tangible impact:

Content & Communication → Writing assistants, meeting note summarizers, and translation tools.
Productivity → AI schedulers, email sorters, and task automation apps.
Design & Creativity → Image generators, video editors, and presentation builders.
Business Intelligence → Market research bots, financial analytics, and customer service chatbots.
Personal Growth → Learning companions, fitness and nutrition trackers, and mental wellness apps.

2. Benefits of Using AI Tools

Speed → Automates repetitive tasks in seconds.
Scalability → Handles data and workflows that are hard for humans to manage alone.
Accessibility → No coding required—most tools are plug-and-play.

3. Challenges and Limitations

Accuracy & Bias → AI can produce convincing but incorrect results.
Over-reliance → Risk of depending on tools without critical thinking.
Privacy Concerns → Sensitive data may not always be handled responsibly.

Tips : Always validate outputs and check how a tool handles your data.

4. Framework for Choosing the Right AI Tool

When exploring new AI tools, use this simple checklist:

Problem-fit → What task am I trying to simplify?
Ease of Use → Can I or my team adopt it quickly?
Integration → Does it work with tools we already use?
Value vs. Cost → Is the time/money saved worth the price?
Data Safety → How is my information stored and protected?

5. The Road Ahead

The next wave of AI will be:

Domain-specific (healthcare AI, legal AI, education AI).
More collaborative, working with humans instead of replacing them.
Better regulated, with clearer standards on ethics and transparency.

Key Takeaway

AI is not here to replace us—it’s here to augment us. The professionals who thrive will be the ones who know how to harness these tools effectively while bringing in human judgment, empathy, and creativity.

Link - https://theresanaiforthat.com/

💡 Final thought: The next time you hit a roadblock in your work, pause and ask yourself: “Is there an AI for that?” Chances are, the answer is yes.

💡 Question for you: Which AI tool has had the biggest positive impact on your daily work so far?

Understanding Java Stream APIs: A Guide for Developers

Bharath S R — Fri, 24 Jan 2025 06:05:56 +0000

Java Stream APIs, introduced in Java 8, revolutionized the way developers process collections of data. Streams provide a functional programming approach, enabling concise, expressive, and readable code for operations like filtering, mapping, and reducing data. In this blog, we will explore the core concepts of Java Stream APIs, their advantages, and practical examples to help you harness their full potential.

What Are Streams?

A Stream is a sequence of elements that supports sequential and parallel aggregate operations. Unlike collections, Streams do not store data; they process it on-demand. This makes them powerful for handling large datasets or performing transformations efficiently.

Key characteristics of Streams include:

No storage: Streams do not modify the underlying data structure.
Laziness: Operations on streams are executed only when a terminal operation is invoked.
Immutability: Streams encourage a functional approach, treating data as immutable.
Possibility of parallelism: Streams can be processed in parallel, leveraging modern multicore architectures.

Components of Java Streams

Stream Creation: Streams can be created from various sources like collections, arrays, or even I/O channels. For example:

// From a List
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Stream<String> stream = names.stream();

// From an Array
int[] numbers = {1, 2, 3, 4, 5};
IntStream intStream = Arrays.stream(numbers);

// Using Stream.of()
Stream<String> stringStream = Stream.of("A", "B", "C");

Intermediate Operations: These operations transform a stream into another stream. They are lazy and executed only when a terminal operation is performed. Examples of intermediate operations:
- filter(): Filters elements based on a predicate.
- map(): Transforms elements using a function.
- sorted(): Sorts the elements.
- distinct(): Removes duplicate elements.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
numbers.stream()
       .filter(n -> n % 2 == 0) // Keep only even numbers
       .map(n -> n * n)        // Square each number
       .forEach(System.out::println); // Print each result

Terminal Operations: These operations produce a result or a side effect and terminate the stream pipeline. Examples of terminal operations:
- forEach(): Performs an action for each element.
- collect(): Converts the stream back into a collection or other structure.
- reduce(): Reduces the elements into a single value using an accumulator.
- count(): Returns the count of elements.

List<String> words = Arrays.asList("apple", "banana", "cherry");
long count = words.stream()
                  .filter(word -> word.startsWith("a"))
                  .count();
System.out.println("Count of words starting with 'a': " + count);

Parallel Streams: By simply invoking parallelStream() instead of stream(), you can process data in parallel.

List<Integer> largeList = IntStream.range(1, 1000).boxed().toList();
largeList.parallelStream()
        .filter(n -> n % 2 == 0)
        .forEach(System.out::println);

Benefits of Java Streams

Declarative code: Streams simplify complex logic with expressive methods.
Efficiency: Streams use lazy evaluation, processing data only when needed.
Parallelism: Parallel streams can dramatically improve performance on large datasets.
Readability: Functional-style operations reduce boilerplate and improve clarity.

Practical Use Cases

Filtering and Transforming Data

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
                                  .filter(name -> name.length() > 3)
                                  .map(String::toUpperCase)
                                  .collect(Collectors.toList());
System.out.println(filteredNames); // Output: [ALICE, CHARLIE, DAVID]

Finding Maximum and Minimum

List<Integer> numbers = Arrays.asList(3, 5, 7, 2, 8);
int max = numbers.stream()
                 .max(Comparator.naturalOrder())
                 .orElseThrow();
System.out.println("Max: " + max); // Output: Max: 8

Grouping and Partitioning

List<String> items = Arrays.asList("apple", "banana", "cherry", "apricot", "blueberry");
Map<Boolean, List<String>> partitioned = items.stream()
                                              .collect(Collectors.partitioningBy(item -> item.startsWith("a")));
System.out.println(partitioned);
// Output: {false=[banana, cherry, blueberry], true=[apple, apricot]}

Best Practices

Use Streams for Declarative Programming: Avoid using loops for tasks like filtering, mapping, and aggregation.
Leverage Method References: Use concise syntax like Class::method whenever possible.
Avoid Side Effects: Streams encourage immutability; avoid modifying variables inside stream operations.
Know When to Use Parallel Streams: Parallelism is powerful but context-dependent. Test performance before adopting it.

Conclusion

Java Stream APIs offer a powerful way to process data with functional-style programming. By mastering streams, you can write clean, efficient, and maintainable code. Whether you're filtering data, transforming collections, or leveraging parallelism, streams are an indispensable tool in modern Java development. Start using them today and see the difference they can make in your projects!

Understanding Java Iterators: A Deep Dive

Bharath S R — Fri, 03 Jan 2025 14:06:09 +0000

When working with collections in Java, an Iterator plays a crucial role in traversing and processing elements efficiently. This blog explores the concept, utility, and implementation of iterators in Java, helping you leverage this tool to manage collections effectively.

What is an Iterator?

An Iterator is an object that allows sequential access to elements in a collection without exposing its underlying structure. It is part of the java.util package and is commonly used with collections like List, Set, and Map.

Why Use Iterators?

Iterators provide a consistent way to traverse collections, irrespective of their type. This consistency is particularly important in complex applications where collections can vary widely in implementation but require uniform processing. Key benefits include:

Abstraction: You don’t need to worry about how the collection is implemented.
Read and Remove: You can read and optionally remove elements during iteration.
Fail-fast Behaviour: Iterators in Java collections detect concurrent modifications and throw ConcurrentModificationException, ensuring data integrity.

How to Use an Iterator

The Iterator interface provides three primary methods:
1.hasNext():

Returns true if there are more elements to iterate over.
Example :

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

2.next():

Returns the next element in the collection.
Throws NoSuchElementException if no elements are left.

3.remove():

Removes the last element returned by the iterator.
Example:

iterator.remove();

Iterator vs Enhanced For Loop

Both iterators and enhanced for-loops simplify collection traversal, but iterators provide more control, such as the ability to remove elements. Enhanced for-loops are ideal for read-only access.

Example:

// Enhanced for-loop
for (String item : list) {
    System.out.println(item);
}

// Using Iterator
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    if (item.equals("remove")) {
        iterator.remove();
    }
}

Iterators with Different Collections

1.List Iterators:

Work with ordered collections.
Example:

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

2.Set Iterators:

No duplicates; order is not guaranteed.
Example:

Set<String> set = new HashSet<>(Arrays.asList("A", "B", "C"));
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

3.Map Iterators:

Use entrySet(), keySet(), or values() to iterate over entries, keys, or values.
Example:

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

Limitations of Iterators

Single-Directional Traversal: Iterators can only move forward.
Concurrent Modification: Modifying a collection while iterating over it (outside remove()) throws ConcurrentModificationException.
Read and Remove Only: Iterators do not support adding elements; for this, use ListIterator.

Conclusion

Java iterators are powerful tools for navigating collections, offering simplicity and consistency. While they have limitations, understanding their use cases and advanced features, like ListIterator, can greatly enhance your ability to manipulate collections efficiently.

Understanding Java Strings: A Comprehensive Guide

Bharath S R — Thu, 19 Dec 2024 04:31:58 +0000

Introduction

In the world of programming, strings play a crucial role in representing and manipulating text data. Java, as a versatile programming language, offers robust support for handling strings, making it an essential topic for developers. This blog provides a comprehensive overview of Java Strings, covering their creation, manipulation, and best practices.

What is a String in Java?

A String in Java is an immutable sequence of characters. Unlike primitive data types, strings are objects that belong to the java.lang.String class. Being immutable means once a String object is created, it cannot be altered. Any modification results in the creation of a new String object.

Creating Strings

Java provides two main ways to create strings:

1.Using String Literals:

String str1 = "Hello, World!";

When a string literal is used, it is stored in the String Pool, a special area of memory that optimises memory usage by reusing instances.

2.Using the new Keyword:

String str2 = new String("Hello, World!");

This approach creates a new object in the heap memory, bypassing the String Pool.

String Methods

The String class in Java offers numerous methods for common operations:

1.Length of a String:

int length = str1.length();

2.Character Extraction:

char ch = str1.charAt(0); // Gets the first character

3.Substring:

String sub = str1.substring(0, 5); // "Hello"

4.String Comparison:

boolean isEqual = str1.equals("Hello, World!");
int result = str1.compareTo("Hello");

5.Case Conversion:

String lower = str1.toLowerCase();
String upper = str1.toUpperCase();

6.Trimming Whitespaces:

String trimmed = str1.trim();

7.Replacing Characters or Substrings:

String replaced = str1.replace("World", "Java");

8.Splitting Strings:

String[] words = str1.split(", ");

String Immutability and Performance

Why Strings are Immutable:

Security: Immutable strings are safer for handling sensitive data like passwords.
Performance: String Pool reuses immutable strings, reducing memory overhead.
Thread-Safety: Immutability makes strings inherently thread-safe.

Performance Tip: For scenarios involving frequent string modifications, use StringBuilder or StringBuffer instead of String to avoid creating multiple objects.

Example:

StringBuilder sb = new StringBuilder("Hello");
sb.append(", Java!");
System.out.println(sb.toString());

String Pool in Java

The String Pool is a special memory area inside the Java Heap. It stores string literals to optimize memory usage. When a string literal is created, the JVM checks the pool for an existing identical string. If found, the reference is reused; otherwise, a new string is added to the pool.

Example:

String s1 = "Java";
String s2 = "Java";
System.out.println(s1 == s2); // true (same reference)

However:

String s3 = new String("Java");
System.out.println(s1 == s3); // false (different references)

Conclusion

Strings in Java are versatile and powerful. Understanding their immutability, the String Pool, and best practices ensures efficient and effective string manipulation. Whether you are formatting text, processing user inputs, or working with files, mastering Java strings is fundamental to becoming a proficient Java developer. Thanks for reading !!

Wrapper Classes in Java

Bharath S R — Mon, 09 Dec 2024 09:50:40 +0000

Understanding Wrapper Classes in Java

Java is a versatile programming language that provides features for both object-oriented and procedural programming. One unique aspect of Java is its wrapper classes, which bridge the gap between primitive data types and objects. In this blog, we will dive into what wrapper classes are, why they are essential, and how to use them effectively in your Java programs.

What Are Wrapper Classes?

Wrapper classes in Java are part of the java.lang package. They provide a way to use primitive data types (‘int’, ‘char’, etc.) as objects. This is crucial in scenarios where objects are required, such as when working with Java Collections (e.g., ArrayList, HashMap) or frameworks like Reflection and Serialization.

Each primitive data type has a corresponding wrapper class:

Key Features of Wrapper Classes

1.Auto-boxing and Unboxing

Java simplifies working with wrapper classes by supporting automatic conversion between primitives and their corresponding wrapper objects:

Autoboxing: Automatic conversion of a primitive type to its wrapper class object
Unboxing: Automatic conversion of a wrapper class object to its primitive type

Example :

int num = 10;
Integer obj = num; // Autoboxing

Integer obj2 = 20;
int num2 = obj2; // Unboxing

2.Utility Methods

Wrapper classes provide several methods to perform operations like type conversion and validation. Examples include:

Integer.parseInt(String s): Converts a string to an int
Double.valueOf(String s): Converts a string to a Double object
Character.isDigit(char ch): Checks if a character is a digit
Boolean.parseBoolean(String s): Parses a string into a boolean value

3. Immutability

Wrapper class objects are immutable, meaning their values cannot be changed once created. This ensures thread safety and consistency in Java programs.

4. Nullability

Unlike primitive types, wrapper objects can hold null values. This feature is useful when working with databases or when a variable's value needs to be optional.

Why Are Wrapper Classes Important?

1.Compatibility with Collections API: Java Collections like ArrayList, HashMap, and others store only objects. Wrapper classes enable primitives to be stored in these collections.
Example:

ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(5); // Autoboxing
numbers.add(10);
System.out.println(numbers);

2.Utility and Conversion: Wrapper classes offer methods to convert between strings and primitives or validate input.

String str = "123";
int num = Integer.parseInt(str); // Convert String to int

3.Framework Compatibility: Reflection, Serialization, and other frameworks require objects, not primitives. Wrapper classes make primitives compatible in such scenarios.

Common Use Cases

Auto-boxing and Unboxing Example

public class WrapperExample {
    public static void main(String[] args) {
        Integer obj = 100; // Autoboxing
        int num = obj;    // Unboxing

        System.out.println("Wrapper Object: " + obj);
        System.out.println("Primitive Value: " + num);
    }
}

Converting String to Primitive and Vice Versa

public class StringConversion {
    public static void main(String[] args) {
        String str = "456";

        // Convert String to int
        int number = Integer.parseInt(str);

        // Convert int to String
        String newStr = Integer.toString(number);

        System.out.println("Integer value: " + number);
        System.out.println("String value: " + newStr);
    }
}

Validating Input Data

public class InputValidation {
    public static void main(String[] args) {
        char ch = '5';

        if (Character.isDigit(ch)) {
            System.out.println(ch + " is a digit.");
        } else {
            System.out.println(ch + " is not a digit.");
        }
    }
}

Things to Keep in Mind

1. Performance Overhead: Autoboxing and unboxing can introduce performance overhead when used in loops or frequently executed code

2. NullPointerException: Accessing a null wrapper object can lead to NullPointerException during unboxing.

3. Memory Usage: Wrapper objects consume more memory compared to primitives. Use primitives where object behavior is not required.

Conclusion

Wrapper classes in Java are an essential tool that allows developers to seamlessly integrate primitive types into object-oriented frameworks and collections. By understanding their features, use cases, and limitations, you can write efficient and error-free Java code.

Whether you're working on a complex application or just learning Java, knowing when and how to use wrapper classes is a skill every developer should master!

Exception Handling in Java

Bharath S R — Thu, 05 Dec 2024 10:46:49 +0000

Introduction

Java exceptions are events that disrupt the normal flow of a program during runtime. They are objects representing errors or unusual conditions that the program should handle to prevent crashing or unexpected behaviour.

Types of Java Exceptions

1.Checked Exceptions

These are exceptions that are checked at compile time
The program must handle these exceptions using a try-catch block or declare them using the throws keyword.
Examples: IOException, SQLException, FileNotFoundException.

2.Unchecked Exceptions

These occur during runtime and are not checked at compile time.
They usually result from programming errors, such as logic mistakes or improper use of APIs.
Examples: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

3.Errors

Represent serious problems that applications should not try to catch.
Examples: OutOfMemoryError, StackOverflowError.

Exception Handling in Java

Java uses the following keywords for exception handling:

try: Code that might throw an exception is enclosed in a try block.
catch: Handles specific exceptions thrown by the try block.
finally: Block that is always executed after try and catch, regardless of whether an exception occurred.
throw: Used to explicitly throw an exception.
throws: Declares exceptions that a method might throw.

Syntax Example

import java.io.*;

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            // Code that may throw an exception
            FileInputStream file = new FileInputStream("test.txt");
        } catch (FileNotFoundException e) {
            // Handling the exception
            System.out.println("File not found: " + e.getMessage());
        } finally {
            // Always executed
            System.out.println("Execution completed.");
        }
    }
}

Commonly Used Exception Classes

IOException: Input-output operations failure.
SQLException: Database access errors.
ClassNotFoundException: Class not found during runtime.
ArithmeticException: Invalid arithmetic operations (e.g., division by zero).
NullPointerException: Attempt to use an object reference that is null.
IllegalArgumentException: Method has been passed an inappropriate argument.

Custom Exceptions

You can create custom exceptions by extending the Exception or RuntimeException class.

class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            throw new MyCustomException("Custom error occurred");
        } catch (MyCustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

Summary

Java exceptions are critical for handling errors and maintaining application stability. They are categorized into checked exceptions (like IOException) that are handled at compile-time, unchecked exceptions (like NullPointerException) that occur during runtime, and errors (like OutOfMemoryError) indicating serious issues.

Java's robust exception-handling mechanism includes keywords like try, catch, finally, throw, and throws, allowing developers to manage errors gracefully. Custom exceptions can also be created to address application-specific issues. By effectively leveraging Java's exception handling, developers can build resilient and user-friendly applications. Happy Coding!!

Lombok

Bharath S R — Wed, 04 Dec 2024 10:17:25 +0000

Introduction

Lombok is a Java library designed to reduce boilerplate code in Java applications. It achieves this by providing annotations that automate repetitive tasks like getters, setters, constructors, equals, hashCode, and more. This helps developers write clean and concise code while maintaining functionality.

Key Features of Lombok

1.Annotations for Boilerplate Reduction

@Getter and @Setter: Automatically generates getter and setter methods.
@ToString: Creates a toString method for the class.
@EqualsAndHashCode: Generates equals and hashCode methods.
@NoArgsConstructor, @AllArgsConstructor, @RequiredArgsConstructor: Automates constructor creation.

2.Builder Pattern Support

@Builder: Implements the builder pattern for object creation.

3.Immutability

@Value: Creates immutable classes (like a final class with private fields, a constructor, getters, and toString).

4.Logging Annotations

@Slf4j, @Log, etc.: Add loggers for common logging frameworks.

Example Usage

import lombok.Data;

@Data
public class User {
    private String firstName;
    private String lastName;
    private int age;
}

This single annotation (@Data) will generate:

getName, setName, getAge, setAge methods
toString method
equals and hashCode methods
A default constructor

Advantages

Reduces boilerplate code significantly
Improves code readability and maintainability
Speeds up development by automating repetitive tasks

Drawbacks

May obscure logic for those unfamiliar with Lombok
Generated code is not visible in the IDE, which might complicate debugging
Dependency on an external library

How to Add Lombok to Your Project

1.Maven

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>

2.Gradle

implementation 'org.projectlombok:lombok:1.18.30'
annotationProcessor 'org.projectlombok:lombok:1.18.30'

3.IDE Support

Install the Lombok plugin in your IDE (IntelliJ IDEA, Eclipse, etc.)
Enable annotation processing in your IDE settings

In conclusion, Lombok is a powerful tool that streamlines Java development by eliminating repetitive boilerplate code, allowing developers to focus on the core functionality of their applications. While it requires some initial familiarity and setup, its productivity benefits far outweigh the learning curve. By adopting Lombok, you can achieve cleaner, more maintainable code and accelerate your development process, making it an essential library for modern Java projects.Happy Coding !!