DEV Community: Gowtham Kalyan

Builder Design Pattern in Java.

Gowtham Kalyan — Sat, 04 Apr 2026 09:04:45 +0000

Introduction

When creating complex objects in Java with many optional parameters, constructors become messy and hard to manage. This leads to unreadable code, bugs, and poor maintainability.

The Builder Pattern solves this problem by allowing you to construct objects step-by-step, making the code more readable, flexible, and scalable.

What is Builder Pattern?

The Builder Pattern is a creational design pattern that separates the construction of a complex object from its representation, allowing you to build objects step by step.

👉 In simple terms:
“Instead of passing everything in a constructor, you build the object piece by piece.”

Real-Time Problem

In my decade of teaching Java, one common issue developers face is handling constructors like this:

User user = new User("Harish", 25, "Hyderabad", "India", "9999999999", true);

Problems:

Hard to remember parameter order
Difficult to read
Not flexible for optional fields

Solution: Builder Pattern

User user = new User.Builder("Harish", 25)
                    .city("Hyderabad")
                    .country("India")
                    .phone("9999999999")
                    .isActive(true)
                    .build();

✔ Much cleaner
✔ More readable
✔ Easy to maintain

Step-by-Step Implementation

Step 1: Create the Main Class

public class User {

    private String name;
    private int age;
    private String city;
    private String country;
    private String phone;
    private boolean isActive;

    // Private constructor
    private User(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.city = builder.city;
        this.country = builder.country;
        this.phone = builder.phone;
        this.isActive = builder.isActive;
    }

Step 2: Create Static Builder Class

    public static class Builder {

        // Required fields
        private String name;
        private int age;

        // Optional fields
        private String city;
        private String country;
        private String phone;
        private boolean isActive;

        public Builder(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public Builder city(String city) {
            this.city = city;
            return this;
        }

        public Builder country(String country) {
            this.country = country;
            return this;
        }

        public Builder phone(String phone) {
            this.phone = phone;
            return this;
        }

        public Builder isActive(boolean isActive) {
            this.isActive = isActive;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

Expert Explanation

In real-world enterprise applications:

Builder improves code readability
Helps create immutable objects
Avoids constructor explosion problem

Our students in Hyderabad often switch to Builder after struggling with large DTO classes in Spring Boot projects.

Why is Builder Pattern Useful?

1. Handles Complex Object Creation

Many fields (required + optional)
Clean and structured construction

2. Improves Readability

Instead of:

new User("Harish", 25, null, null, null, false);

You write:

new User.Builder("Harish", 25).build();

3. Supports Immutability

Object state is set only once
No setters required

4. Avoids Telescoping Constructor Problem

Instead of:

User(String name)
User(String name, int age)
User(String name, int age, String city)
...

5. Flexible and Maintainable

Easy to add new fields
No breaking changes

Real-Time Use Cases

Builder Pattern is widely used in:

DTO objects in Spring Boot
REST API request/response models
Configuration objects
Immutable classes

Example Scenarios

Creating user profiles
Building API request payloads
Constructing complex queries

Edge Cases You Should Know

❗ 1. Missing Required Fields

new User.Builder(null, 0).build();

✔ Add validation inside build() method

❗ 2. Mutable Objects Inside Builder

If fields are mutable:

List<String> roles;

✔ Use defensive copies to avoid external modification

❗ 3. Overuse in Simple Classes

Builder is not needed for:

Small objects (2–3 fields)
Simple POJOs

Builder vs Other Patterns

Feature	Builder Pattern	Factory Pattern	Singleton Pattern
Purpose	Build complex objects	Create objects	Single instance
Object Creation	Step-by-step	Centralized	One-time
Flexibility	Very High	High	Low
Use Case	Complex objects	Dynamic objects	Shared resource

When to Use Builder Pattern

Use it when:

Object has many parameters
Some parameters are optional
You want immutable objects
You need readable object creation

When NOT to Use

Avoid when:

Object is simple
Few fields only
No optional parameters

Best Practices (From Experience)

Make class immutable
Validate inside build()
Use meaningful method names
Avoid exposing setters

Quick FAQ

1. What problem does Builder Pattern solve?

It solves complex object creation with many optional parameters.

2. Is Builder Pattern thread-safe?

Yes, if the object is immutable.

3. Can Builder replace constructors?

Yes, especially for complex objects.

4. Is Builder used in Spring Boot?

Yes, commonly used for DTOs and configurations.

5. What is the difference between Builder and Factory?

Builder constructs step-by-step, Factory creates objects directly.

Final Thoughts

The Builder Pattern is one of the most practical and widely used design patterns in modern Java development. It improves readability, maintainability, and scalability.

Mastering it will make your code cleaner and more professional—especially in real-time enterprise applications.

Start Your Journey Today

Enroll in the Best AI powered Core JAVA Online Training in Hyderabad and gain real-time skills that companies are actually looking for.

📍 Follow the complete roadmap to become a Java Full Stack Developer:
👉 https://www.ashokit.in/java-full-stack-developer-roadmap

What Happens Internally When You Call String intern in Java

Gowtham Kalyan — Thu, 02 Apr 2026 07:17:05 +0000

1. Introduction

The intern method in Java is used to manage memory efficiently by storing string objects in a special memory area called the String Pool. Understanding how String.intern() works internally is important for writing optimized Java applications.

2. What is String Pool

The String Pool is a special memory area in the heap where unique string literals are stored. It helps in saving memory by reusing existing string objects instead of creating new ones.

Summary

Stores unique string values.
Avoids duplicate objects.
Improves memory efficiency.

3. What is String intern Method

The intern() method checks whether a string already exists in the String Pool. If it exists, it returns the reference of that string. If not, it adds the string to the pool and returns its reference.

Syntax

java
String s = str.intern();

Summary

Returns pooled string reference.
Adds string to pool if not present.

4. Internal Working of String intern

When you call intern() on a string

The JVM checks the String Pool.
If the string already exists, it returns the existing reference.
If the string does not exist, it is added to the pool.
A reference to the pooled string is returned.

Example


java id="q4k8xp"
public class InternExample {
    public static void main(String[] args) {
        String s1 = new String("Java");
        String s2 = s1.intern();

        String s3 = "Java";

        System.out.println(s2 == s3); // true
    }
}

Explanation

s1 creates a new object in heap.
intern adds or retrieves the string from pool.
s3 directly refers to pooled string.
Both s2 and s3 point to same reference.

5. Behavior Before and After Java 7

Before Java 7
String Pool was stored in PermGen memory.

After Java 7
String Pool is moved to heap memory, making it more flexible and scalable.

Summary

Improved memory management.
Better scalability.

6. Advantages of Using intern Method

Reduces memory usage.
Avoids duplicate string objects.
Improves performance in certain cases.

7. When to Use intern Method

Use it when there are many duplicate strings.
Useful in memory-sensitive applications.
Avoid overusing it unnecessarily.

8. Common Mistakes to Avoid

Assuming intern always improves performance.
Using it excessively can increase overhead.
Not understanding heap and pool behavior.

9. Key Takeaways

intern method works with String Pool.
Ensures only one copy of string exists.
Returns reference from pool.
Helps optimize memory usage.

10. Useful Resources

Learn more from the AI powered Core JAVA Online Training in Hyderabad.
https://www.ashokit.in/courses/core-java-online-training

Follow the Java Full Stack Developer Roadmap to become job ready.
https://www.ashokit.in/java-full-stack-developer-roadmap

11. FAQ Section

11.1 What does String intern do in Java

It returns a reference from the String Pool if the string exists, otherwise it adds the string to the pool and returns the reference.

11.2 Where is the String Pool stored

After Java 7, the String Pool is stored in heap memory.

11.3 Does intern create a new object

It creates a new object in the pool only if it does not already exist.

11.4 Why use intern method

It helps reduce memory usage by avoiding duplicate string objects.

11.5 Is intern method always recommended

No, it should be used only when necessary because it may add overhead.

12. Conclusion

The String.intern() method plays a key role in memory optimization by managing string objects in the String Pool. By understanding its internal working, you can write more efficient Java programs. To gain hands-on experience, consider learning from the AI powered Core JAVA Online Training in Hyderabad.

13. Promotional Content

Start learning today with the AI powered Core JAVA Online Training in Hyderabad.

Difference Between map and flatMap in Java Stream API

Gowtham Kalyan — Wed, 01 Apr 2026 07:48:14 +0000

1. Introduction

Understanding the difference between map and flatMap is very important when working with the Stream API in Java. Both are intermediate operations used to transform data, but they behave differently when handling collections.

2. What is map in Stream API

The map method is used to transform each element of a stream into another form. It takes one value and returns one value.

In simple terms, map performs a one to one transformation.

Example Using map


java id="p9k2xm"
import java.util.*;

public class MapExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("java", "python", "c++");

        list.stream()
            .map(s -> s.toUpperCase())
            .forEach(System.out::println);
    }
}

Summary

Transforms each element.
Returns one value for each input.
Used for simple data transformation.

3. What is flatMap in Stream API

The flatMap method is used to transform each element into multiple elements and then flatten them into a single stream.

In simple terms, flatMap performs a one to many transformation and flattens the result.

Example Using flatMap

java id="p7x3qd"
import java.util.*;

public class FlatMapExample {
    public static void main(String[] args) {
        List<List<String>> list = Arrays.asList(
            Arrays.asList("Java", "Python"),
            Arrays.asList("C++", "JavaScript")
        );

        list.stream()
            .flatMap(l -> l.stream())
            .forEach(System.out::println);
    }
}

Summary

Transforms and flattens data.
Handles nested collections.
Returns a single stream.

4. Key Differences Between map and flatMap

Feature	map	flatMap
Transformation	One to one	One to many
Output	Stream of values	Flattened stream
Use Case	Simple transformation	Nested collections
Complexity	Simple	Slightly advanced

5. When to Use map and flatMap

Use map when each input element maps to a single output value.
Use flatMap when each element produces multiple values or when working with nested collections.

6. Common Mistakes to Avoid

Using map for nested collections leads to complex structures.
Not understanding flattening in flatMap.
Confusing one to one and one to many transformations.

7. Key Takeaways

map is used for simple transformations.
flatMap is used for flattening nested data.
Both are important in Stream API.
Choosing the right method improves code readability.

8. Useful Resources

Learn more from the No 1 Core JAVA Online Training in ameerpet.
https://www.ashokit.in/courses/core-java-online-training

Follow the Java Full Stack Developer Roadmap to become job ready.
https://www.ashokit.in/java-full-stack-developer-roadmap

9. FAQ Section

9.1 What is the difference between map and flatMap in Java

map transforms each element into a single value, while flatMap transforms elements into multiple values and flattens them into a single stream.

9.2 When should I use flatMap instead of map

Use flatMap when working with nested collections or when one input produces multiple outputs.

9.3 Can map return multiple values

No, map returns only one value for each input element.

9.4 Is flatMap more powerful than map

flatMap is more flexible because it can handle complex transformations and flatten nested data.

9.5 Are map and flatMap intermediate operations

Yes, both map and flatMap are intermediate operations in the Stream API.

10. Conclusion

Understanding the difference between map and flatMap is essential for working effectively with Java Stream API. By choosing the right method, you can simplify your code and handle complex data structures easily. To gain hands-on experience, consider joining the No 1 Core JAVA Online Training in ameerpet.

11. Call to Action

Start learning today with the No 1 Core JAVA Online Training in ameerpet.

How Do You Create a Custom Exception in Java?

Gowtham Kalyan — Tue, 31 Mar 2026 06:42:40 +0000

1. Introduction

In Java, a custom exception is a user-defined exception created to handle specific business logic errors.

Instead of using only built-in exceptions, you can define your own exception to make your code:

More readable
More meaningful
Easier to debug

2. Why Do We Need Custom Exceptions?

Explanation

Sometimes built-in exceptions are not enough. For example:

Invalid user age
Insufficient balance
Invalid input in business logic

In such cases, custom exceptions provide clear and domain-specific error messages.

3. Steps to Create Custom Exception

Step 1: Extend Exception Class

For checked exception → extend Exception
For unchecked exception → extend RuntimeException

4. Example (Checked Custom Exception)

// Step 1: Create custom exception
class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

// Step 2: Use custom exception
public class CustomExceptionExample {
    public static void main(String[] args) {
        int age = 16;

        try {
            if (age < 18) {
                throw new InvalidAgeException("Age must be 18 or above");
            }
            System.out.println("Eligible");
        } catch (InvalidAgeException e) {
            System.out.println(e.getMessage());
        }
    }
}

5. Explanation of Code

InvalidAgeException extends Exception → Checked exception
Constructor passes message to parent class
throw new InvalidAgeException(...) → explicitly throws exception
catch block handles it

Output:

Age must be 18 or above

6. Example (Unchecked Custom Exception)

class InvalidAmountException extends RuntimeException {
    public InvalidAmountException(String message) {
        super(message);
    }
}

public class UncheckedCustomException {
    public static void main(String[] args) {
        int amount = -100;

        if (amount < 0) {
            throw new InvalidAmountException("Amount cannot be negative");
        }

        System.out.println("Valid amount");
    }
}

7. Explanation

Extends RuntimeException → Unchecked exception
No need for try-catch (optional)
Used for programming or validation errors

8. Key Points

Custom exceptions improve code clarity
Can be checked or unchecked
Use meaningful names (e.g., InvalidAgeException)
Always provide a clear message

9. Best Practices

Use checked exceptions for recoverable conditions
Use unchecked exceptions for logic errors
Keep exception classes simple and focused
Add constructors for flexibility

10. Summary

Custom exceptions = user-defined exceptions
Created by extending Exception or RuntimeException
Used for handling specific application scenarios
Improve readability and maintainability

Java Full Stack Developer Roadmap

To master exception handling and advanced Java concepts:

👉 https://www.ashokit.in/java-full-stack-developer-roadmap

Promotional Content

Want to master Java Exception Handling including Custom Exceptions?

Best Core JAVA Online Training in ameerpet

How Does HashMap Work Internally in Java?

Gowtham Kalyan — Mon, 30 Mar 2026 07:35:40 +0000

1. Introduction

HashMap is one of the most important data structures in Java used to store key-value pairs.

It provides constant time complexity O(1) for put() and get() operations (on average) by using a technique called hashing.

2. Basic Working Concept

Explanation

HashMap internally uses:

Array (Bucket array)
Hashing (hashCode)
Linked List / Tree (for collision handling)

Each key-value pair is stored in a structure called a Node.

3. Internal Structure

A simplified structure of HashMap:

static class Node<K, V> {
    final int hash;
    final K key;
    V value;
    Node<K, V> next;
}

Explanation

hash → hash value of the key
key → actual key
value → stored value
next → reference to next node (for collision handling)

4. How put() Works

Example

import java.util.HashMap;

public class PutExample {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "Python");
    }
}

Step-by-Step Explanation

Hash Calculation

hashCode() is called on the key.
Example: key 1 → hash value generated.

Index Calculation

Index = (n - 1) & hash
Determines position in the bucket array.

Store Entry

If bucket is empty → insert directly.
If not → handle collision.

5. How get() Works

Example

import java.util.HashMap;

public class GetExample {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Java");

        System.out.println(map.get(1));
    }
}

Explanation

Calculate hash of key
Find bucket index
Traverse nodes (if multiple)
Match using equals()
Return value

6. Collision Handling

Explanation

Collision occurs when two keys map to the same index.

Before Java 8

Stored using Linked List

After Java 8

If bucket size > 8 → converted to Balanced Tree (Red-Black Tree)
Improves performance from O(n) → O(log n)

7. Example of Collision

import java.util.HashMap;

public class CollisionExample {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();

        map.put(1, "A");
        map.put(17, "B"); // Might collide depending on capacity

        System.out.println(map);
    }
}

Explanation

Both keys may go to same bucket.
Stored as:
- Linked List OR
- Tree (if threshold exceeded)

8. Important Concepts

Load Factor

Default: 0.75
Determines when to resize the HashMap

Resizing (Rehashing)

When capacity exceeds threshold:
- New array is created (double size)
- All elements are rehashed

9. Performance

Operation	Average Time	Worst Case
put()	O(1)	O(log n)
get()	O(1)	O(log n)

10. Key Points

Uses hashCode() and equals()
Allows one null key and multiple null values
Not thread-safe
Faster retrieval due to hashing

11. Real-Time Use Case

Caching data
Storing configurations
Database result mapping
Counting frequency of elements

Java Full Stack Developer Roadmap

To master concepts like HashMap, Collections, and System Design:

👉 https://www.ashokit.in/java-full-stack-developer-roadmap

Promotional Content

Want to deeply understand Java Collections and crack interviews?

Top Core JAVA Online Training in 2026

How Do You Design a Scalable Systems?

Gowtham Kalyan — Sat, 28 Mar 2026 07:14:40 +0000

Designing a scalable system is one of the most important aspects of modern software development. A scalable system can handle increasing amounts of traffic, users, and data without compromising performance.

Introduction
What is Scalability?
Types of Scalability
Key Principles of Scalable System Design
Core Components of a Scalable System
Best Practices
Real-Time Example
Conclusion

1. Introduction

As applications grow, they must handle more users and data. A system that works fine for 1,000 users may fail at 1 million users if not designed properly. Scalability ensures your system can grow seamlessly.

2. What is Scalability?

Scalability is the ability of a system to handle increased load by adding resources.

Example:

More users accessing a website
More transactions in an application
Larger datasets to process

3. Types of Scalability

Vertical Scalability (Scaling Up)

Increase resources (CPU, RAM) of a single server
Simple but has limits

Horizontal Scalability (Scaling Out)

Add more servers to distribute load
Preferred for large-scale systems

4. Key Principles of Scalable System Design

Load Distribution

Use load balancers to distribute traffic across multiple servers.

Stateless Services

Design services so they don’t store session data locally.

Database Scaling

Use replication (read replicas)
Use sharding for large datasets

Caching

Use caching systems (e.g., Redis) to reduce database load.

Asynchronous Processing

Use message queues (Kafka, RabbitMQ) for background tasks.

Microservices Architecture

Break application into smaller, independent services.

5. Core Components of a Scalable System

Load Balancer → Distributes traffic
Application Servers → Handle business logic
Database → Stores data (SQL/NoSQL)
Cache Layer → Speeds up data access
Message Queue → Handles async processing
CDN → Delivers static content faster

6. Best Practices

Use connection pooling
Optimize database queries
Monitor system performance
Implement auto-scaling
Ensure fault tolerance
Use containerization (Docker, Kubernetes)

7. Real-Time Example

Scenario:

A video streaming platform experiences rapid growth.

Solution:

Use CDN → Faster video delivery
Add load balancers → Distribute traffic
Use microservices → Independent scaling
Implement caching → Reduce DB load

Result:

Handles millions of users
High availability
Low latency

8. Conclusion

Designing a scalable system requires careful planning, the right architecture, and continuous monitoring. By following best practices like horizontal scaling, caching, and load balancing, you can build systems that grow efficiently with user demand.

Key Takeaways

Scalability ensures system growth without performance loss
Horizontal scaling is preferred for large systems
Use caching, load balancing, and microservices
Monitor and optimize continuously

Promotional Content

If you want to master system design concepts like scalability, performance optimization, and real-time architecture, this is the perfect opportunity.

👉 Top Core JAVA Online Training in 2026

Java Full Stack Developer Roadmap

Want to become a complete Java developer?

👉 Follow this step-by-step roadmap:
🔗 https://www.ashokit.in/java-full-stack-developer-roadmap

This roadmap will guide you through:

Core Java
Advanced Java
Spring Boot & Microservices
Frontend Technologies
Real-time Projects

Start your journey today and become a job-ready Java Full Stack Developer!

What is status codes (200, 404, 500)?

Gowtham Kalyan — Fri, 27 Mar 2026 07:09:52 +0000

When a client (like a browser or API tool) sends a request to a server, the server responds with a status code. This code tells you:

👉 “What happened to your request?”

What is an HTTP Status Code?

An HTTP status code is a 3-digit number returned by the server to indicate the result of a request.

1. 200 OK – Success ✅

200 means the request was successful.

When you see 200:

Data fetched successfully
Request processed correctly

Example:

```http id="s1"
GET /users/101 → 200 OK




👉 User data returned successfully

---

##  2. 404 Not Found – Resource Missing ❌

**404** means the requested resource was **not found on the server**.

###  When you see 404:

* Wrong URL
* Resource doesn’t exist
* Invalid ID

###  Example:



```http id="s2"
GET /users/999 → 404 Not Found

👉 User doesn’t exist

3. 500 Internal Server Error – Server Issue ⚠️

500 means something went wrong on the server side.

When you see 500:

Code error (NullPointerException, etc.)
Server crash
Unexpected failure

Example:

```http id="s3"
POST /users → 500 Internal Server Error




👉 Server failed to process request

---

##  Quick Comparison

| Status Code | Meaning      | Type            | Example Scenario          |
| ----------- | ------------ | --------------- | ------------------------- |
| 200         | Success      | ✅ Success       | Data fetched successfully |
| 404         | Not Found    | ❌ Client Error  | Invalid URL/resource      |
| 500         | Server Error | ⚠️ Server Error | Bug in backend            |

---

##  Status Code Categories

All HTTP status codes fall into 5 groups:

| Range | Category      | Meaning               |
| ----- | ------------- | --------------------- |
| 1xx   | Informational | Request received      |
| 2xx   | Success       | Request successful    |
| 3xx   | Redirection   | Further action needed |
| 4xx   | Client Errors | Problem with request  |
| 5xx   | Server Errors | Problem on server     |

---

##  Real-Time Example

Imagine using a website:

* Page loads → **200 OK** ✅
* Page not found → **404 Error** ❌
* Site crashes → **500 Error** ⚠️

---

##  Why Status Codes Matter

* Help debug issues quickly
* Improve API design
* Provide clear communication between client & server
* Essential for frontend-backend interaction

---

##  Conclusion

HTTP status codes are a critical part of web communication. Understanding codes like **200, 404, and 500** helps developers build and debug applications effectively.

---

##  Learn More

Want to master REST APIs, Spring Boot, and backend development?

👉 **[No 1 Core JAVA Online Training in 2026](https://ashokitech.com/core-java-online-training/)**


---

What is pom.xml?

Gowtham Kalyan — Thu, 26 Mar 2026 07:09:38 +0000

When working with Java projects using Apache Maven, one file plays a central role in managing everything—pom.xml. It acts as the backbone of any Maven-based application.

What is pom.xml?

pom.xml (Project Object Model) is an XML file used by Maven to define:

Project structure
Dependencies
Build configurations
Plugins
Project metadata

👉 In simple terms, it is the configuration file that tells Maven how to build your project.

Why is pom.xml Important?

Without pom.xml, Maven cannot:

Download dependencies
Build the project
Run tests
Package the application

👉 It acts as the instruction manual for your project.

Basic Structure of pom.xml

Here is a simple example:

xml id="d8l2kf"
<project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.0</version>
        </dependency>
    </dependencies>
</project>

Key Elements in pom.xml

1. groupId

Represents the organization or company 👉 Example: com.ashokit

2. artifactId

Name of the project (JAR/WAR file) 👉 Example: student-management

3. version

Version of the project 👉 Example: 1.0.0

4. dependencies

List of external libraries required

👉 Maven automatically downloads them from repositories.

5. plugins

Used to perform build tasks like compilation, testing, packaging

Dependency Management Example

Instead of manually adding JAR files, just define them:

xml id="v0r8kp"
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>

👉 Maven handles downloading and linking automatically.

Advantages of pom.xml

📦 Centralized dependency management
⚙️ Simplifies build process
🧩 Reduces manual configuration
🔄 Easy to maintain and update
🚀 Improves project consistency

Real-Time Use Case

In enterprise projects:

Multiple developers work on the same codebase
pom.xml ensures everyone uses the same dependencies and versions

👉 This avoids conflicts and “it works on my machine” issues.

Conclusion

pom.xml is the heart of any Maven-based Java project. It defines how your project is built, what dependencies it uses, and how it behaves throughout its lifecycle. Understanding pom.xml is essential for any Java developer working with modern tools and frameworks.

Promotional Content

Want to master Maven, pom.xml, and build real-time Java applications?

👉 Enroll in the Best Core JAVA Online Training in 2026

Hi

Gowtham Kalyan — Wed, 25 Mar 2026 11:53:45 +0000

What is HttpURLConnection?

Gowtham Kalyan — Wed, 25 Mar 2026 07:17:21 +0000

HttpURLConnection is a class in Java used to send HTTP requests and receive responses from web servers. It belongs to the java.net package and is commonly used to interact with REST APIs and web services.

📌 Why Do We Use HttpURLConnection?

To call REST APIs 🌐
To send GET, POST, PUT, DELETE requests
To fetch data from web servers
To integrate external services (payment APIs, weather APIs, etc.)

📌 How HttpURLConnection Works

Create a URL
Open connection
Set request method (GET/POST)
Send request
Read response

🔹 Example: HTTP GET Request

java id="h3k92l"
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpExample {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://jsonplaceholder.typicode.com/posts/1");
        HttpURLConnection con = (HttpURLConnection) url.openConnection();

        con.setRequestMethod("GET");

        int status = con.getResponseCode();
        System.out.println("Response Code: " + status);

        BufferedReader br = new BufferedReader(
                new InputStreamReader(con.getInputStream()));

        String line;
        StringBuilder response = new StringBuilder();

        while ((line = br.readLine()) != null) {
            response.append(line);
        }
        br.close();

        System.out.println("Response: " + response.toString());
    }
}

🔹 Example: HTTP POST Request

java id="o9w2ks"
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class PostExample {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://jsonplaceholder.typicode.com/posts");
        HttpURLConnection con = (HttpURLConnection) url.openConnection();

        con.setRequestMethod("POST");
        con.setDoOutput(true);

        String jsonInput = "{\"title\":\"Java\",\"body\":\"Learning\",\"userId\":1}";

        OutputStream os = con.getOutputStream();
        os.write(jsonInput.getBytes());
        os.flush();
        os.close();

        int responseCode = con.getResponseCode();
        System.out.println("POST Response Code: " + responseCode);
    }
}

🚀 Important Methods

Method	Description
`setRequestMethod()`	Sets HTTP method (GET, POST, etc.)
`getResponseCode()`	Returns HTTP status code
`getInputStream()`	Reads response data
`getOutputStream()`	Sends request data
`setDoOutput(true)`	Enables sending data

🔥 Advantages

Built-in Java API (no external libraries needed)
Supports HTTP & HTTPS
Useful for API integration
Fine control over request/response

⚠️ Limitations

Verbose and complex code
Harder to manage compared to modern libraries
No automatic JSON parsing

👉 In real-world projects, developers often use libraries like:

Apache HttpClient
OkHttp
Spring RestTemplate / WebClient

🎯 Real-Time Use Cases

Calling REST APIs
Fetching weather/news data
Payment gateway integration
Microservices communication

✅ Conclusion

HttpURLConnection is a core Java class for handling HTTP communication. While it may seem a bit complex, it gives you full control over network requests and is widely used in backend systems.

Learning this concept is crucial if you're preparing for real-time projects and interviews through Top Core JAVA Online Training in Hyderabad.

Why Are Generics Used in Java?

Gowtham Kalyan — Tue, 24 Mar 2026 07:09:41 +0000

Generics were introduced in Java (from Java 5) to make code safer, cleaner, and more reusable. They allow you to define classes, interfaces, and methods with type parameters, so you can work with different data types without sacrificing type safety.

🔹 1. Type Safety (Main Reason)

Before generics, Java collections stored objects as Object, which could lead to runtime errors.

❌ Without Generics:

List list = new ArrayList();
list.add("Java");

Integer num = (Integer) list.get(0); // Runtime error (ClassCastException)

✅ With Generics:

List<String> list = new ArrayList<>();
list.add("Java");

String value = list.get(0); // Safe

👉 Generics ensure errors are caught at compile time, not runtime.

🔹 2. Eliminates Explicit Type Casting

Without generics, you must manually cast objects when retrieving them.

❌ Without Generics:

String str = (String) list.get(0);

✅ With Generics:

String str = list.get(0);

👉 This makes code cleaner and easier to read.

🔹 3. Code Reusability

Generics allow you to write one class or method that works with multiple data types.

Example:

class Box<T> {
    T value;

    void set(T value) {
        this.value = value;
    }

    T get() {
        return value;
    }
}

👉 Same class works for:

Box<Integer>
Box<String>
Box<Double>

🔹 4. Compile-Time Checking

Generics help the compiler verify correctness early.

List<Integer> list = new ArrayList<>();
list.add("Java"); // ❌ Compile-time error

👉 Prevents invalid data from entering collections.

🔹 5. Better API Design

Generics improve method and class design by making them:

More flexible
More type-safe
Easier to maintain

Example from Java Collections:

public interface List<E> { }

🔹 6. Supports Advanced Features

Generics enable powerful features like:

Bounded types (<T extends Number>)
Wildcards (?, extends, super)
Generic methods

🔹 Real-Time Example

public static <T> void printArray(T[] arr) {
    for (T element : arr) {
        System.out.println(element);
    }
}

👉 Works with any type of array:

Integer[]
String[]
Double[]

🔹 Summary

Generics are used because they provide:

✔ Type Safety
✔ Code Reusability
✔ No Explicit Casting
✔ Compile-Time Error Detection
✔ Cleaner and Maintainable Code

🚀 Final Thoughts

Generics are a core part of modern Java development. Without them, working with collections and APIs would be error-prone and messy.

If you want to master Core Java concepts like Generics with real-time examples and projects, check out:
👉 No 1 Core JAVA Online Training in Hyderabad

What is Method Reference (::) in Java 8? A Complete Guide

Gowtham Kalyan — Mon, 23 Mar 2026 06:35:51 +0000

Java 8 introduced several powerful features to make code more concise and functional. One of the most useful among them is the Method Reference (::).

If you’re working with Lambda Expressions, understanding method references will take your code to the next level.

🔹 What is Method Reference?

A Method Reference is a shorthand syntax used to refer to a method without executing it.

👉 It is represented using the :: operator.

Instead of writing a lambda expression, you can directly reference an existing method.

🔹 Basic Syntax

ClassName::methodName

🔹 Why Use Method Reference?

✅ Reduces code length
✅ Improves readability
✅ Reuses existing methods
✅ Works seamlessly with functional interfaces

🔹 Example: Lambda vs Method Reference

Using Lambda:

```java id="h5t1hp"
list.forEach(x -> System.out.println(x));




### Using Method Reference:



```java id="5h0l1c"
list.forEach(System.out::println);

👉 Cleaner and more readable!

🔹 Types of Method References

✅ 1. Static Method Reference

```java id="9o0bzz"
class Demo {
static void display(String msg) {
System.out.println(msg);
}
}

list.forEach(Demo::display);




---

### ✅ 2. Instance Method Reference (of a Particular Object)



```java id="h2p5fw"
class Demo {
    void show(String msg) {
        System.out.println(msg);
    }
}

Demo d = new Demo();
list.forEach(d::show);

✅ 3. Instance Method Reference (of Arbitrary Object)

```java id="9re4hj"
list.sort(String::compareToIgnoreCase);




---

### ✅ 4. Constructor Reference



```java id="u6k0g6"
Supplier<List<String>> supplier = ArrayList::new;

🔹 When to Use Method Reference?

👉 Use method references when:

You already have a method that matches a functional interface
You want cleaner and shorter code
You are working with Streams API

🔹 Real-Time Use Cases

Iterating collections (forEach)
Sorting data (Comparator)
Stream operations (map, filter)
Object creation using constructors

🔥 Key Difference: Lambda vs Method Reference

Feature	Lambda Expression	Method Reference
Syntax	Verbose	Short & Clean
Reusability	Limited	High
Readability	Medium	High

🚀 Final Thoughts

Method references are a powerful feature in Java 8 that help you write clean, readable, and efficient code. Once you start using them with Streams and functional interfaces, your coding style becomes more modern and professional.

🎯 Learn More – Upgrade Your Java Skills

Join the Best Core JAVA Online Training in Hyderabad and gain hands-on experience with real-time projects, expert guidance, and interview preparation.