DEV Community: Arshi Saxena

Mastering SOLID Principles for Java Interviews

Arshi Saxena — Tue, 10 Dec 2024 13:53:58 +0000

The SOLID principles are foundational guidelines for writing maintainable, scalable, and flexible software. Understanding and applying these principles not only improves your coding practices but also prepares you for answering crucial Java interview questions.

Why SOLID Principles Matter

SOLID principles ensure your code is:

Easy to maintain: Makes changes to the code without breaking existing functionality.
Scalable: Enables you to add features without rewriting or overhauling the current codebase.
Flexible and reusable: Minimizes dependencies, promoting modularity.

In interviews, understanding SOLID demonstrates your ability to design robust systems, adapt to new requirements, and manage technical debt effectively.

The SOLID Principles Unpacked

1. Single Responsibility Principle (SRP)

A class should have only one reason to change, focusing on a single responsibility.

Why it matters: Reduces tight coupling and unexpected side effects.

Example:

User class for managing user data.
UserService class for handling operations like login() or logout().

This separation ensures changes to user operations don’t affect user data management.

2. Open/Closed Principle (OCP)

Software entities should be open for extension but closed for modification.

Why it matters: Prevents breaking existing code while adding new functionality.

Example: Calculating the area of shapes.
Instead of modifying a Shape class for every new shape, define an interface Shape and let individual shape classes like Circle or Rectangle implement it.

3. Liskov Substitution Principle (LSP)

Subclasses should be replaceable with their base classes without altering the correctness of the program.

Why it matters: Ensures polymorphism is implemented correctly.

Example:
A superclass method returns Number; a subclass can override it to return a more specific type like Integer (covariant return).

4. Interface Segregation Principle (ISP)

No client should be forced to depend on methods it does not use.

Why it matters: Reduces unnecessary dependencies.

Example:
Splitting a large Vehicle interface into smaller ones like Engine or SunRoof. Vehicles without a sunroof don’t need to implement irrelevant methods.

5. Dependency Inversion Principle (DIP)

Depend on abstractions, not concrete implementations.

Why it matters: Promotes decoupled and testable code.

Example:
In a Spring Boot application, inject dependencies like DataAccessLayer or ServiceLayer through interfaces rather than concrete implementations.
This is called Dependency Injection Design Pattern.

Why SOLID is Key for Java Interviews

Interviewers often test your understanding of:

Applying these principles: Expect questions about structuring code for scalability and maintenance.
Real-world examples: Be ready to explain scenarios like designing shape hierarchies (OCP) or implementing dependency injection (DIP).

Closing Thoughts

Mastering SOLID principles gives you the confidence to design better systems and handle tough interview questions. By following these principles, you balance flexibility for future features with the stability of existing code — a skill every developer needs.

Happy coding!

Sorting Smarts in Java: TreeSet and TreeMap

Arshi Saxena — Sat, 07 Dec 2024 04:30:00 +0000

In our previous post, we discussed Comparable and Comparator, which are the building blocks for sorting elements in Java.

Now that we understand the fundamentals, let’s explore how collections like TreeSet and TreeMap leverage these interfaces to maintain elements in a sorted order.

TreeSet: A Set That Sorts

TreeSet is part of Java’s Set collection. Unlike HashSet, which does not guarantee any order, TreeSet stores its elements in a sorted order. It relies on the Comparable or Comparator implementation to determine how elements should be ordered.

Key Characteristics of TreeSet:

Sorted Order: Automatically maintains elements in sorted order.
Unique Elements: Does not allow duplicate elements.
Implementation: Based on a Red-Black Tree.

Example 1: Natural Ordering with TreeSet

// Implementing Comparable Interface
class Product implements Comparable<Product> {
    private int id;
    private double price;
    private String category;

    public Product(int id, double price, String category) {
        this.id = id;
        this.price = price;
        this.category = category;
    }

    // Overriding compareTo()
    @Override
    public int compareTo(Product o) {
        // Natural ordering by id
        return Integer.compare(this.id, o.id);
    }

    @Override
    public String toString() {
        return "Product [id=" + id + ", price=" + price + ", category=" +
        category + "]";
    }

    // Getters
    public int getId() {
        return id;
    }

    public double getPrice() {
        return price;
    }

    public String getCategory() {
        return category;
    }
}

public class TreeSetExample {
    public static void main(String[] args) {
        Set<Product> treeSet = new TreeSet<>();
        treeSet.add(new Product(3, 200.0, "Non-Essentials"));
        treeSet.add(new Product(1, 100.0, "Essentials"));
        treeSet.add(new Product(2, 150.0, "Essentials"));

        System.out.println("TreeSet Sorted with Natural Ordering:");
        treeSet.forEach(System.out::println);
    }
}

Output:

TreeSet Sorted with Natural Ordering (by ID):
Product [id=1, price=100.0, category=Essentials]
Product [id=2, price=150.0, category=Essentials]
Product [id=3, price=200.0, category=Non-Essentials]

Explanation:

The TreeSet sorts the products based on their id in ascending order because we defined the natural order using the Comparable interface.
Duplicate products with the same id would be ignored due to the nature of Set.

Example 2: Custom Ordering with TreeSet

We can also specify a custom sorting order using a Comparator. For instance, let’s sort by category and price:

public class CustomTreeSetExample {
    public static void main(String[] args) {
        // Define the Comparator for custom ordering
        Comparator<Product> productComparator = (p1, p2) -> {
            // Comparing on the basis of category
            int categoryComparison = p1.getCategory()
                                        .compareTo(p2.getCategory());

            // Comparing on the basis of price when categories are same
            return categoryComparison != 0 
                   ? categoryComparison 
                   : Double.compare(p1.getPrice(), p2.getPrice());
        };

        // Create TreeSet with the custom comparator
        Set<Product> treeSet = new TreeSet<>(productComparator);

        treeSet.add(new Product(3, 200.0, "Non-Essentials"));
        treeSet.add(new Product(1, 100.0, "Essentials"));
        treeSet.add(new Product(2, 250.0, "Essentials"));

        System.out.println(
            "TreeSet Sorted with Custom Ordering (by Category and Price):"
        );
        treeSet.forEach(System.out::println);
    }
}

Output:

TreeSet Sorted with Custom Ordering (by Category and Price):
Product [id=1, price=100.0, category=Essentials]
Product [id=2, price=250.0, category=Essentials]
Product [id=3, price=200.0, category=Non-Essentials]

Explanation:

The TreeSet now sorts first by the category and then by price within the same category using the custom comparator.

TreeMap: A Map That Sorts

TreeMap is similar to TreeSet, but it is a Map that stores key-value pairs in a sorted order. Like TreeSet, it uses the Comparable or Comparator interface to sort the keys.

Key Characteristics of TreeMap:

Sorted Keys: Stores keys in a sorted order.
Unique Keys: Does not allow duplicate keys.
Implementation: Based on a Red-Black Tree.

Example 1: Natural Ordering with TreeMap

// Implementing Comparable Interface
class Product implements Comparable<Product> {
    private int id;
    private double price;
    private String category;

    public Product(int id, double price, String category) {
        this.id = id;
        this.price = price;
        this.category = category;
    }

    // Overriding compareTo() method
    @Override
    public int compareTo(Product o) {
        // Natural ordering by id
        return Integer.compare(this.id, o.id);
    }

    @Override
    public String toString() {
        return "Product [id=" + id + ", price=" + price + ", category=" +
        category + "]";
    }

    // Getters
    public int getId() {
        return id;
    }

    public double getPrice() {
        return price;
    }

    public String getCategory() {
        return category;
    }
}

public class TreeMapExample {
    public static void main(String[] args) {
        // Initializing TreeMap with Product as key and Quantity as value
        Map<Product, Integer> productMap = new TreeMap<>();

        productMap.put(new Product(3, 200.0, "Non-Essentials"), 5);
        productMap.put(new Product(1, 100.0, "Essentials"), 10);
        productMap.put(new Product(2, 150.0, "Essentials"), 8);

        // Displaying the TreeMap
        System.out.println("TreeMap with Natural Ordering (Product by
        ID):");
        productMap.forEach((product, qty) -> System.out.println(product +
        " | Quantity: " + qty));
    }
}

Output

TreeMap with Natural Ordering (Product by ID):
Product [id=1, price=100.0, category=Essentials] | Quantity: 10
Product [id=2, price=150.0, category=Essentials] | Quantity: 8
Product [id=3, price=200.0, category=Non-Essentials] | Quantity: 5

Code Explanation

Product Class:
The Product class implements the Comparable interface to define the natural ordering based on the id.
TreeMap:
The TreeMap stores Product objects as keys, and the sorting order is determined by the compareTo() method of the Product class. As you can see, the TreeMap arranges the products based on their id in ascending order.
Sorting in Action:
When we insert the products into the TreeMap, it automatically sorts them by their id. The quantities are stored as values, and each Product is mapped to a specific quantity.

TreeMap: Custom Ordering with Comparator

Now, let’s use a custom comparator to sort the products in a TreeMap based on their category and price. This allows us to define a sorting logic that doesn’t rely on the natural ordering by id.

Example: TreeMap with Custom Ordering (By Category and Price)

public class TreeMapCustomOrdering {
    public static void main(String[] args) {
        // Custom comparator for sorting by category and price
        Comparator<Product> customComparator = (p1, p2) -> {
            // Comparing on the basis of category
            int categoryComparison = p1.getCategory()
                           .compareTo(p2.getCategory());

            // Comparing on the basis of price when categories are same
            return categoryComparison != 0 
                   ? categoryComparison 
                   : Double.compare(p1.getPrice(), p2.getPrice());
        };

        // Initializing TreeMap with custom comparator
        Map<Product, Integer> customSortedMap = new TreeMap<>(customComparator);

        customSortedMap.put(new Product(1, 100.0, "Essentials"), 10);
        customSortedMap.put(new Product(2, 500.0, "Essentials"), 15);
        customSortedMap.put(new Product(3, 200.0, "Non-Essentials"), 5);
        customSortedMap.put(new Product(4, 400.0, "Non-Essentials"), 7);
        customSortedMap.put(new Product(5, 300.0, "Essentials"), 8);

        // Displaying the TreeMap
        System.out.println("TreeMap with Custom Ordering (By Category and
        Price):");
        customSortedMap.forEach((product, qty) ->
        System.out.println(product + " | Quantity: " + qty));
    }
}

Output

TreeMap with Custom Ordering (By Category and Price):
Product [id=1, price=100.0, category=Essentials] | Quantity: 10
Product [id=5, price=300.0, category=Essentials] | Quantity: 8
Product [id=2, price=500.0, category=Essentials] | Quantity: 15
Product [id=3, price=200.0, category=Non-Essentials] | Quantity: 5
Product [id=4, price=400.0, category=Non-Essentials] | Quantity: 7

Code Explanation

Custom Comparator:
The custom comparator first compares the category fields. If the categories are the same, it then compares the price fields. This allows sorting by multiple criteria: first by category, and if the categories are the same, then by price.
TreeMap with Comparator:
The TreeMap is initialized with the custom comparator, which sorts the products accordingly. The products are first sorted by their category (alphabetically), and if two products have the same category, they are sorted by price in ascending order.
Dynamic Sorting:
This approach provides more flexibility than natural ordering, as we can define any comparison logic we need, including sorting by multiple attributes.

Conclusion

In this post, we explored how collections like TreeSet and TreeMap maintain sorted order using natural ordering and custom ordering via Comparable and Comparator. These tree-based collections are powerful tools when you need to keep elements in order without manually sorting them every time.

Key Takeaways:

TreeSet: A sorted set based on natural or custom order, with unique elements.
TreeMap: A sorted map that stores key-value pairs, with keys sorted in natural or custom order.

By combining the flexibility of Comparable and Comparator with these collections, you can efficiently manage sorted data structures in your Java programs.

Happy Coding!

Sorting Smarts in Java: Comparable and Comparator

Arshi Saxena — Fri, 06 Dec 2024 08:21:11 +0000

Sorting is a fundamental operation in Java, especially when dealing with collections. Java offers two main strategies for sorting: natural ordering using Comparable and custom ordering using Comparator.

For advanced use cases, collections like TreeSet and TreeMap leverage these strategies to maintain sorted order dynamically. This will be covered in depth in the next post.

Natural Ordering: The Comparable Interface

Comparable provides the default or natural ordering of objects. A class implements this interface and overrides the compareTo() method to define how objects of that class should be compared.

Key Characteristics of Comparable:

Interface Type: Not a functional interface (cannot be used with lambdas).
Sorting Criterion: A single, consistent sorting logic.
Usage: For objects with a natural comparison, such as integers, strings, or IDs.

Example: Sorting by ID

// Implementing Comparable Interface
class Product implements Comparable<Product> {
    private int id;
    private double price;
    private String category;

    public Product(int id, double price, String category) {
        this.id = id;
        this.price = price;
        this.category = category;
    }

    // Overriding compareTo() method
    @Override
    public int compareTo(Product o) {
        return Integer.compare(this.id, o.id); // Natural ordering by id
    }

    @Override
    public String toString() {
        return "Product [id=" + id + ", price=" + price + ", category=" +
        category + "]";
    }

    // Getters
    public int getId() {
        return id;
    }

    public double getPrice() {
        return price;
    }

    public String getCategory() {
        return category;
    }
}

public class ProductSortingExample {
    public static void main(String[] args) {
        List<Product> productList = new ArrayList<>();
        productList.add(new Product(3, 200.0, "Non-Essentials"));
        productList.add(new Product(1, 100.0, "Essentials"));
        productList.add(new Product(2, 150.0, "Essentials"));

        // Sorting using Comparable
        Collections.sort(productList);

        System.out.println("List Sorted with Comparable -> Natural Ordering");
        list.forEach(System.out::println);

    }
}

Output

List Sorted with Comparable -> Natural Ordering
Product [id=1, price=100.0, category=Essentials]
Product [id=2, price=150.0, category=Essentials]
Product [id=3, price=200.0, category=Non-Essentials]

Code Explanation

Defining Natural Order:
The compareTo method compares the id fields of Product objects. This provides the natural ordering for sorting.
Natural Sorting:
The Collections.sort(productList) method sorts the productList based on the natural ordering provided by the compareTo method. After sorting, the Product objects are arranged in ascending order of their id.
Tree-Based Collections:
This sorting behavior is crucial when working with collections such as TreeSet,TreeMap and others. These collections automatically maintain elements in sorted order based on the Comparable implementation, and we’ll demonstrate this in the next post.

Custom Ordering: The Comparator Interface

Comparator allows you to define custom sorting criteria, independent of the natural ordering. It’s a functional interface, so it can be implemented using lambdas or method references.

Key Characteristics of Comparator:

Interface Type: Functional interface (can be used with lambdas).
Sorting Criterion: Flexible, supports multiple custom criteria.
Usage: Ideal for sorting by attributes other than the natural order or for multi-level sorting.

Example: Sorting by `category` and `price`

public class NaturalVsCustomOrdering {

    public static void main(String[] args) {
        // Initializing List of Products
        List<Product> list = new ArrayList<>(Arrays.asList(
                new Product(1, 100.0, "Essentials"),
                new Product(2, 500.0, "Essentials"),
                new Product(3, 200.0, "Non-Essentials"),
                new Product(4, 400.0, "Non-Essentials"),
                new Product(5, 300.0, "Essentials")
        ));

        // Defining the Custom Comparator
        Comparator<Product> customComparator = (p1, p2) -> {
            // Comparing on the basis of category
            int categoryComparison = p1.getCategory()
                           .compareTo(p2.getCategory());

            // Comparing on the basis of price when categories are same
            return categoryComparison != 0 
                   ? categoryComparison 
                   : Double.compare(p1.getPrice(), p2.getPrice());
        };

        // Sorting the List using the Comparator
        Collections.sort(list, customComparator);

        System.out.println("List Sorted with Comparator -> Custom Ordering");
        list.forEach(System.out::println);
    }
}

Output

List Sorted with Comparator -> Custom Ordering
Product [id=1, price=100.0, category=Essentials]
Product [id=5, price=300.0, category=Essentials]
Product [id=2, price=500.0, category=Essentials]
Product [id=3, price=200.0, category=Non-Essentials]
Product [id=4, price=400.0, category=Non-Essentials]

Code Explanation

Defining Custom Order:
The custom comparator compares the category fields of Product objects. If two products have the same category, the comparator then compares the price fields to sort by price within each category. This approach allows us to define a sorting order that is not strictly natural but based on specific criteria.
Sorting with Collections.sort:
The Collections.sort(list, comparator) method uses the custom comparator to sort the list. This method will first order the products by their category. If products belong to the same category, they will be sorted by their price in ascending order.
Tree-Based Collections:
This custom ordering approach also applies to collections like TreeSet and TreeMap, which use a comparator to maintain a sorted order of their elements. We'll demonstrate how these collections work with custom sorting in the next post.

Comparing Comparable and Comparator

Feature	`Comparable`	`Comparator`
Purpose	Defines natural ordering.	Allows custom ordering.
Implementation	Implement the `Comparable` interface.	Use the `Comparator` interface.
Functional Interface	No, cannot use lambdas.	Yes, can use lambdas.
Flexibility	Single sorting criterion.	Multiple sorting criteria.
In-Class Definition	Implemented within the class itself.	Implemented as an external class or lambda.

Key Takeaways

Use Comparable for Natural Ordering:
Best for objects with a single, consistent sorting logic.
Use Comparator for Custom Ordering:
Ideal for flexible or multi-level sorting criteria.
Choose the Right Tool:

Use compareTo for intrinsic ordering logic.
Use Comparator for scenarios requiring more flexibility or dynamic sorting.

By understanding the difference between these interfaces, you can choose the right approach to sort your objects effectively in Java!

Happy Coding!

Demystifying hashCode() and equals(): The Backbone of Java Hash Collections

Arshi Saxena — Thu, 05 Dec 2024 13:39:20 +0000

When working with Java's hash-based collections like HashMap and HashSet, the methods hashCode() and equals() play a critical role. Understanding their interplay can help you avoid subtle bugs and optimize object comparison.

Introduction

While determining the equality of primitive values is straightforward, comparing custom objects requires additional guidance.

For instance, collections like HashMap and HashSet rely on you to define how your custom objects should be differentiated. This is where hashCode() and equals() step in, providing the logic needed for these collections to function correctly.

How Elements Are Stored in a HashMap

To understand why hashCode() and equals() are important, let’s first explore how HashMap stores elements under the hood:

1. Array of Buckets:
A HashMap internally maintains an array where each slot (or bucket) holds one or more entries. These entries are key-value pairs.

2. Index Calculation Using hashCode():

When you add a key to the map, its hashCode() method computes a numeric hash value.
This value determines the index of the bucket where the key-value pair will be stored.

3. Handling Collisions:

If multiple keys produce the same bucket index (due to a hash collision), they are stored as a linked list or a balanced tree (depending on Java version).
Within the bucket, the equals() method distinguishes between the keys.

Visualization

Let’s imagine adding three keys to a HashMap where two keys collide:

Bucket Index	Content
0	[Key1, Value1]
1	[Key2, Value2] → [Key3, Value3]

Key1 is stored in Bucket 0.
Key2 and Key3 are stored in Bucket 1 because they have the same hash index. The equals() method differentiates them.

Why `hashCode()` and `equals()` Matter

Java collections like HashMap and HashSet rely on these methods to:

Store objects efficiently.
Determine equality for lookups and retrievals.

Failing to implement these methods correctly can lead to:

Duplicate entries: When logically identical objects are treated as distinct.
Unexpected behaviors: Keys failing to retrieve values.

How They Work Together

1. hashCode() Determines the Bucket

A hashCode() generates a numeric hash for an object.
This hash value determines the bucket where the object will be stored in a hash table.

2. equals() Resolves Collisions Within the Bucket

If two objects have the same hash code, they end up in the same bucket (collision).
The equals() method is then used to identify the specific object.

The Contract Between `hashCode()` and `equals()`

The relationship between hashCode() and equals() is governed by a strict contract to ensure consistent behavior in hash-based collections:

1. If two objects are equal according to equals(), they must have the same hashCode().

This ensures that logically identical objects are stored in the same bucket.

2. Two objects with the same hashCode() are not guaranteed to be equal.

This is known as a hash collision, where different objects map to the same hash code.
In such cases, the equals() method is used to determine whether the objects are genuinely equal.

Remember: Breaking this contract can lead to unpredictable behavior in collections like HashMap and HashSet, such as duplicate entries or lookup failures.

Implementation Example

Let’s implement hashCode() and equals() for a custom Person class:

import java.util.HashMap;
import java.util.Objects;

class Person {
    private final String name; // final ensures immutability
    private final int id; // final ensures immutability

    Person(String name, int id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public int hashCode() {
        // Use Objects.hash() to compute hashCode based on the fields
        /* Benefit: 
         * > This eliminates the need to manually compute the hash code,
         *   and it also handles null values 
         * > If any of the fields are null, it won't throw a
         *   NullPointerException
         * */
        // Using both 'id' and 'name' for hash value
        return Objects.hash(id, name);
    }

    @Override
    public boolean equals(Object o) {
        // Checking whether the two references point to the same memory
        // If true, it implies that they are the exact same object
        if (this == o) return true;

        // Checking type to see if the classes are derivative of each other
        if (o == null || getClass() != o.getClass()) return false;
        // Type-casting
        Person person = (Person) o;

        // Use Objects.equals() for null-safe 'name' comparison
        /* > The Objects.equals() method compares the name fields of two
         *   Person objects, safely handling null values (returns true
         *   if both are null, or if both are non-null and equal) 
         * > Benefit: This reduces the need for manual null checks and
         *   simplifies the comparison process
         * */
        return id == person.id && Objects.equals(name, person.name);
    }
}

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

        Person p1 = new Person("Alice", 123);
        Person p2 = new Person("Bob", 123);
        Person p3 = new Person("Alice", 123);

        System.out.println(p1.equals(p3)); // true

        map.put(p1, "Engineer");
        map.put(p2, "Doctor");
        map.put(p3, "Scientist");

        System.out.println(map.size()); // 2
        System.out.println(map.get(p1)); // Scientist
        System.out.println(map.get(p2)); // Doctor
    }
}

What’s Happening in the Code?

Bucket Assignment:
The hashCode() method places p1 and p3 in the same bucket because their hash codes are identical.
Equality Check:
The equals() method confirms that p1 and p3 are logically equal. Hence, the value for p1 is overridden by p3.
Distinct Keys:
p2 has the same id as p1 but a different name. Therefore, it’s stored in a separate bucket.

Best Practices and Takeaways

Always override both hashCode() and equals().
- Only overriding one of them can lead to inconsistent behavior in collections.
Rely on immutable fields when implementing these methods.
- Changes to mutable fields used in equality or hash computations can disrupt collections.
Use Objects.hash() and Objects.equals().
- These utility methods simplify implementation and handle null values gracefully.

Key Takeaways

hashCode() places objects in buckets; equals() distinguishes them.
Correct implementation ensures consistent behavior in collections like HashMap and HashSet.
Using best practices makes your code robust and less error-prone.

By understanding and implementing the hashCode() and equals() methods correctly, you can leverage the full power of hash-based collections in Java.

Happy Coding!

StringBuilder vs StringBuffer in Java

Arshi Saxena — Mon, 11 Nov 2024 10:21:51 +0000

In Java, when working with mutable strings (strings that can be modified), you may need to choose between StringBuilder and StringBuffer. While both are mutable classes that allow modification of their values, they differ significantly in terms of thread safety, performance, and application. Here, we’ll compare their characteristics and provide code examples to illustrate when to use each one.

Key Differences: StringBuilder vs. StringBuffer

Feature	`StringBuilder`	`StringBuffer`
Mutability	Mutable	Mutable
Stored in	Heap (does not use String Pool)	Heap (does not use String Pool)
Thread Safety	Not thread-safe	Thread-safe
Synchronization	Not synchronized	Synchronized
Performance	Faster due to lack of synchronization	Slower due to synchronization overhead
Use Case	Single-threaded scenarios	Multi-threaded scenarios where thread-safety is required

Let’s explore each class in more detail.

1. `StringBuilder`: The Efficient Choice for Single-Threaded Environments

StringBuilder is a mutable class, meaning it allows modifications to its content.
It is thread-unsafe, so it’s ideal for single-threaded scenarios.
Not synchronized: StringBuilder is faster than StringBuffer due to the absence of synchronization overhead.
Multi-threaded limitation: Using StringBuilder in multi-threaded environments without additional safety measures can lead to race conditions and other concurrency issues.

Example: Demonstrating Thread Unsafety in `StringBuilder`

In this example, we use two threads to append characters to a StringBuilder instance. However, due to the lack of synchronization, we encounter race conditions:

public class StringBuilderBasics {

    public void threadUnsafe() {
        // Common resource being shared
        StringBuilder builder = new StringBuilder();

        // Thread appending "A" 1000 times
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                builder.append("A");
            }
        });

        // Thread appending "B" 1000 times
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                builder.append("B");
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Result: 1840 (unpredictable)
        System.out.println("Length: " + builder.toString().length());
    }

    public static void main(String[] args) {
        new StringBuilderBasics().threadUnsafe();
    }
}

Explanation:

Due to thread-unsafety, the final length of the StringBuilder output is unpredictable (e.g., 1840 instead of 2000).
This happens because both threads attempt to append characters simultaneously, leading to overwrites or dropped operations.

Takeaway: Use StringBuilder only in single-threaded environments or when thread-safety is handled externally.

2. `StringBuffer`: The Safe Option for Multi-Threaded Environments

StringBuffer is mutable, allowing modifications to its content.
It is synchronized, which makes it thread-safe.
Ideal for multi-threaded environments where thread safety is necessary.
Performance cost: Synchronization introduces overhead, so StringBuffer is slower than StringBuilder.

Example: Thread Safety in `StringBuffer`

Here’s the same example as above, but this time using StringBuffer:

public class StringBufferBasics {

    public void threadSafe() {
        // Common resource being shared
        StringBuffer buffer = new StringBuffer();

        // Thread appending "A" 1000 times
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                buffer.append("A");
            }
        });

        // Thread appending "B" 1000 times
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                buffer.append("B");
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Result: 2000
        System.out.println("Length: " + buffer.toString().length());
    }

    public static void main(String[] args) {
        new StringBufferBasics().threadSafe();
    }
}

Explanation:

StringBuffer ensures that both threads append safely, achieving the expected length of 2000.
While the final string is thread-safe, the output may be interleaved (e.g., “AAABBB...” mixed together) as thread execution order is non-deterministic.

Takeaway: Use StringBuffer for multi-threaded applications where data consistency is crucial and synchronization is needed.

Choosing the Right Class

To decide between StringBuilder and StringBuffer, consider the following:

Use StringBuilder in single-threaded scenarios where performance is critical and thread-safety isn’t a concern.
Use StringBuffer in multi-threaded scenarios where you need mutable string operations and require thread safety to avoid race conditions.

Conclusion

This comparison should help you make an informed choice between StringBuilder and StringBuffer. Understanding the trade-offs in mutability, performance, and thread safety can lead to better decision-making when working with strings in Java.

Happy Coding!

Strings: Understanding Mutability and Immutability

Arshi Saxena — Sun, 10 Nov 2024 05:46:51 +0000

In Java, strings are often manipulated, combined, and stored across applications, so understanding the difference between immutable and mutable string handling is crucial for writing efficient code. This post explores the concepts of mutability and immutability in Java strings, diving into why Java provides distinct classes like String, StringBuilder, and StringBuffer.

1. The Immutability of `String` in Java

In Java, a String is immutable, meaning once a String object is created, its value cannot be changed. This property is beneficial in terms of security, performance, and memory efficiency in multi-threaded environments. Immutability ensures that:

Consistency: Once a string is assigned a value, it remains constant.
Thread Safety: Multiple threads can safely use the same String instance without synchronization.
Memory Efficiency: Java has an internal String Pool to manage String objects efficiently. This pool stores a single copy of each literal string, reusing it wherever possible.

Example:

String greeting = "Hello";
greeting = greeting + " World";  // A new String object is created
System.out.println(greeting);  // Output: Hello World

In the example, concatenating " World" does not modify the original string but rather creates a new one. This process can become inefficient when dealing with repeated modifications, as we'll see next.

2. Using String in Mutable Scenarios: Drawbacks

While String's immutability is a valuable trait, it can lead to memory and performance issues if used in situations where frequent modifications are necessary. Each time a String is changed, a new object is created, which increases memory usage and adds strain on the garbage collector.

Consider this example of alphabet concatenation:

private String alphabetConcat() {
    String series = "";
    for (int i = 0; i < 26; i++) {
        series += (char) ('a' + i);
        System.out.println(series); // Outputs: a ab abc abcd ...
    }
    return series;
}

Explanation:

Each iteration creates a new String object because of String's immutability, and as a result, this code runs with a time complexity of O(n^2), making it highly inefficient.

Additionally, this approach results in memory inefficiency because each intermediate String object is stored separately in the heap. These unused objects accumulate and contribute to increased garbage collection overhead.

3. Mutable Alternatives: `StringBuilder` and `StringBuffer`

Java offers mutable alternatives like StringBuilder and StringBuffer to handle cases where strings are frequently modified.

Using StringBuilder for Efficient Mutability

StringBuilder is a mutable class, meaning it allows in-place modification of strings. This improves performance by avoiding the creation of intermediate objects, making it the ideal choice for scenarios involving heavy string manipulation. Here’s how it works in our previous example:

private String alphabetConcat() {
    StringBuilder series = new StringBuilder();
    for (int i = 0; i < 26; i++) {
        series.append((char) ('a' + i));
        System.out.println(series); // Outputs: a ab abc abcd ...
    }
    return series.toString();
}

Here, StringBuilder modifies the same object throughout the loop, resulting in a time complexity of O(n), making it far more efficient than String.

Key Points to Remember

String is immutable and backed by the String Pool for memory optimization.
StringBuilder and StringBuffer are mutable. StringBuilder is faster but not thread-safe, whereas StringBuffer is synchronized and thread-safe.
Use StringBuilder in single-threaded scenarios with frequent modifications.
Use String when immutability is needed, or when minimal modifications are expected.

Conclusion

This post establishes the groundwork for understanding when to use String, StringBuilder, or StringBuffer based on mutability and efficiency. In the next posts, we'll dive deeper into the differences between StringBuilder and StringBuffer, exploring thread safety and concurrency scenarios.

Happy Coding!

Strings: Checking for Palindromes

Arshi Saxena — Sat, 09 Nov 2024 10:20:18 +0000

In this post, we’ll walk through a common interview question—checking if a given string is a palindrome. This problem is a great exercise for understanding pointers, loops, and conditional logic in Java.

Problem Statement

Write a Java method that checks if a given string is a palindrome. A palindrome is a word or phrase that reads the same forwards and backwards (e.g., “noon” or “madam”).

Solution Overview

The solution leverages a two-pointer technique to check characters from both ends of the string, moving towards the center. By comparing characters at corresponding positions, we can determine if the string is a palindrome without having to reverse it.

Key Points of the Approach:

Two-Pointer Technique: Check characters from both directions.
Early Exit: Stop as soon as a mismatch is found.
Optimization: Only traverse up to half the string length for efficiency.

Code Solution

Here’s the code for the solution:

public class StringPalindromeQuestion {

    // Method to check if a given string is a palindrome
    private boolean isPalindrome(String string) {
        if (string != null) {
            for (int i = 0, j = string.length() - 1; i < string.length()
            / 2; i++, j--) {
                if (string.charAt(i) != string.charAt(j)) {
                    return false;
                }
            }
        }
        return true;
    }

    public static void main(String[] args) {
        StringPalindromeQuestion palindrome = new StringPalindromeQuestion();

        String oddString = "abcdcba";    // Palindrome with odd length
        String evenString = "abccba";    // Palindrome with even length
        String nonPalindrome = "asfgsa"; // Not a palindrome

        // Result: true
        System.out.println(palindrome.isPalindrome(oddString));

        // Result: true
        System.out.println(palindrome.isPalindrome(evenString));

        // Result: false
        System.out.println(palindrome.isPalindrome(nonPalindrome));

        // Testing with null
        // Result: true
        System.out.println(palindrome.isPalindrome(null));
    }
}

Explanation

1. Two-Pointer Approach:

We initialize two pointers: one at the start (i) and one at the end (j).
We compare characters at these positions (string.charAt(i) and string.charAt(j)) and increment i and decrement j after each comparison.
The loop runs only up to string.length() / 2, ensuring efficient traversal regardless of whether the length is odd or even.

2. Odd vs. Even Length:

For even-length strings (e.g., "abccba"), the method checks up to the midpoint, so no middle character remains unchecked.
For odd-length strings (e.g., "abcdcba"), the middle character naturally does not affect palindrome status.

3. Null Handling:
The method checks if the string is null at the beginning to avoid NullPointerException.

Example Output

Odd-length Palindrome: "abcdcba" returns true.
Even-length Palindrome: "abccba" returns true.
Non-Palindrome: "asfgsa" returns false.
Null String: returns true (a null input is considered a palindrome by this implementation).

Interview Tip 💡

Understanding two-pointer techniques is valuable for solving many string-based problems efficiently. This technique avoids extra space complexity and makes code execution faster by limiting unnecessary comparisons.

Conclusion

This solution provides a clean and efficient way to check for palindromes in Java. Try using this approach with different string inputs to further solidify your understanding of pointer manipulation and string traversal.

Happy Coding!

Strings: Basic Methods in Java-Interview Essentials

Arshi Saxena — Fri, 08 Nov 2024 16:05:59 +0000

Strings are a fundamental part of almost every Java application. Whether you are building complex algorithms, working with user input, or performing text manipulation, knowing how to efficiently use Java’s String class methods is a must.

In this post, we’ll dive into some of the basic but essential string methods that every Java developer should know, especially for interviews.

1. `equalsIgnoreCase()`: Case-Insensitive Comparison

The equalsIgnoreCase() method allows you to compare two strings without considering their case.
It’s a handy method when you want to check for equality without worrying about uppercase or lowercase differences.

Example:

String string = "Hello";
System.out.println(string.equalsIgnoreCase("HeLLo")); // Result: true

2. `toLowerCase()` and `toUpperCase()`: Case Conversion

Converting a string to all lowercase or uppercase is a common task, and Java provides built-in methods to do this.

Example:

String string = "Hello";
System.out.println(string.toLowerCase()); // Result: hello
System.out.println(string.toUpperCase()); // Result: HELLO

3. `startsWith()` and `endsWith()`: Check String Boundaries

If you need to check if a string starts or ends with a particular sequence of characters, these methods are what you need.

They’re case-sensitive by default, so be mindful when using them.

Example:

String string = "Hello";
System.out.println(string.startsWith("h")); // Result: false
System.out.println(string.endsWith("lo")); // Result: true

Common Interview Question

How do you check if a given string starts with a specific substring, ignoring the case?

This is a common interview question to test your understanding of string manipulation and case-insensitivity in Java.

The startsWith() method is case-sensitive by default, so to perform a case-insensitive check, you need to standardize both the string and the substring to the same case using toLowerCase() or toUpperCase().

Here’s how you can implement it:

String givenString = "Example";
String givenCharacterString = "e";
System.out.println(
    givenString.toLowerCase().startsWith(
        givenCharacterString.toLowerCase()
    )
); // Result: true

Explanation:

startsWith(): This method checks if the string begins with the specified substring, but it is case-sensitive.
toLowerCase(): Converts both the original string and the substring to lowercase to perform a case-insensitive comparison.

By converting both strings to the same case, you can ensure that the method works even if the input string or substring contains mixed-case characters.

4. `toCharArray()`: Convert String to Character Array

If you need to work with individual characters, converting a string to a character array is easy with the toCharArray() method.

Example:

String string = "Hello";
System.out.println(
    Arrays.toString(string.toCharArray())
); // Result: [H, e, l, l, o]

Explanation:

We used Arrays.toString() to print the character array in the format [H, e, l, l, o]. If we directly use System.out.println(string.toCharArray()), the output will display the array elements as a string Hello.

This is due to the fact that the println() method has an overloaded version for character arrays.

For more details on this behavior, refer to Polymorphism: Decoding Method Overloading in Java.

5. `charAt()`, `indexOf()`, and `lastIndexOf()`: Character Search

These methods help you find specific characters within a string.

charAt(): Returns the character at a given index in the string.
indexOf(): Finds the first occurrence of a specified character. Returns -1 if not present.
lastIndexOf(): Finds the last occurrence of a specified character. Returns -1 if not present.

Example:

String string = "Hello";
System.out.println(string.charAt(0)); // Result: H
System.out.println(string.indexOf('l')); // Result: 2
System.out.println(string.lastIndexOf('l')); // Result: 3

6. `contains()`: Substring Presence Check

When you want to check if a string contains a particular substring, the contains() method comes to the rescue.

Example:

String string = "Hello";
System.out.println(string.contains("l")); // Result: true

7. `substring()`: Extracting Parts of a String

The substring() method is used to extract a portion of a string. There are two variations of this method:

1. public String substring(int begIndex)

Extracts a substring starting from the specified index (inclusive) to the end of the string.

Example:

   String completeString = "This is a Complete String";
   System.out.println(completeString.substring(5)); 
   // Result: is a Complete String

2. public String substring(int begIndex, int endIndex)

Extracts a substring starting from begIndex (inclusive) up to endIndex (exclusive).

Common Interview Question:
Q. Print the first 4 characters of the string.

Solution:

   String completeString = "This is a Complete String";
   System.out.println(completeString.substring(0, 4)); 
   // Result: This

Explanation:
Since endIndex is exclusive, it includes characters at indices 0, 1, 2, and 3.

8. `replace()`: Replacing Characters or Substrings

The replace() method is used to replace characters or substrings with new values. It’s an essential method for text processing.

Example:

String string = "Hello";
System.out.println(string.replace('l', 'p')); // Result: Heppo
System.out.println(string.replace("pp", "ll")); // Result: Hello

9. `split()`: Splitting Strings into Parts

The split() method divides a string into an array of substrings based on a delimiter. It’s useful for parsing text data.

Example:

String string2 = " Welcome to Strings ";
System.out.println(Arrays.toString(string2.split(" ")));
// Result: [, Welcome, to, Strings]

Common Interview Question:

Q. Given a sentence in a string, print each word along with its length.

To solve this, use the split() method to separate words, then loop through the array to calculate and print their lengths.

Example:

String str = "Coding with Java";
String[] words = str.split(" ");
for (String word : words) {
    System.out.println(word + " - " + word.length());
}

Result

Coding - 6
with - 4
Java - 4

10. `compareTo()`: Lexicographical Comparison

The compareTo() method compares two strings lexicographically. It returns a positive number if the string is greater, a negative number if it's smaller, or 0 if they’re equal.

Example:

String string = "Hello";
System.out.println(string.compareTo("Hllo")); // Result: -7

11. `isBlank()` and `isEmpty()`: Check String State

isBlank(): Returns true if the string is empty or contains only whitespace.
isEmpty(): Returns true if the string has no characters at all.

Example:

String string1 = "    ";
System.out.println(string1.isBlank()); // Result: true
System.out.println(string1.isEmpty()); // Result: false

12. `matches()`: Regular Expression Matching

The matches() method checks if the string matches the given regular expression. It’s a powerful tool for text pattern matching.

Example:

String string = "Hello";
System.out.println(string.matches("(.*)l(.*)")); // Result: true

13. `trim()`: Removing Extra Whitespaces

The trim() method removes any leading and trailing spaces from a string, making it easier to work with user input or clean data.

Example:

String string2 = " Welcome to Strings ";
System.out.println(string2.trim()); // Result: Welcome to Strings

Conclusion

Mastering these string methods is crucial for anyone working in Java, especially when preparing for interviews.
Whether you're dealing with user input, processing text data, or manipulating strings for performance, these methods are your go-to tools.
From handling case sensitivity to trimming whitespace, Java provides a rich set of utilities for string manipulation that every developer should be comfortable with.

Happy Coding!

Strings: Garbage Collection and Immutability in Java

Arshi Saxena — Wed, 06 Nov 2024 11:40:49 +0000

In Java, strings play a unique role in memory management due to their immutability and interning characteristics. These concepts not only improve performance but also introduce nuances to memory handling that are often essential in interviews.

Let’s explore Garbage Collection, and Immutability in depth, with notes on how the String Pool and JVM memory management interact with these concepts.

This post builds on concepts discussed in the previous article on String Pool and Memory Management. Reviewing that article first will provide a helpful foundation for understanding the topics covered here.

1. String Garbage Collection

In Java, string literals behave differently in terms of garbage collection (GC).

1. Unreferenced Literals in the String Pool

String string3 = "World"; // Stored in String Pool

// A new string is created in the pool due to case-sensitivity
string3 = "WORLD";

In this example, the original "World" is still in the String Pool, even though string3 is reassigned.
The JVM retains unreferenced literals in the pool, allowing future reuse, but these literals are NOT subject to garbage collection like regular heap objects.

2. Heap Objects

String str1 = new String("World"); // Stored in Heap

// String Pool reference is used now
// leaving the previous "World" eligible for GC in Heap
str1 = "WORLD";

When created with new, a String goes to the heap instead of the String Pool.
If the reference changes, as with str1, the unused "World" string in the heap can be garbage-collected since it is no longer referenced.

2. String Immutability

Strings in Java are immutable—once created, they cannot be modified. Any “modification” results in a new string object rather than changing the existing one.

Practical Effects of Immutability

1. Compile-Time Concatenation (Optimization with Literals)

   String string5 = "This" + "String";

When concatenating literals, the Java compiler optimizes by performing the concatenation at compile time.
The resulting string ("ThisString") is directly stored in the String Pool, avoiding the heap entirely.
This process is also known as Constant Pool Folding.

2. Runtime Concatenation (No Optimization)

   String string1 = "Hello";
   string1 = string1 + "Hello"; // Stored in Heap

When one or more operands are variables (non-literals), concatenation happens at runtime, resulting in a heap object that doesn’t reside in the String Pool.
Example: The original "Hello" literal remains in the pool, while the concatenated "HelloHello" string is stored in the heap, confirming the immutability of the original "Hello".

3. Using concat() Method

   String string2 = "Hello";
   string2 = string2.concat("Hello"); // Stored in Heap

The concat() method always performs runtime concatenation, placing the new string in the heap, irrespective of whether the operands are literals or variables.

4. Applying intern() Method

   String string3 = "World".concat(" says Hello").intern();

Process:

First, the concat() operation creates a new string in the heap with the value "World says Hello", which string3 initially references.
When we call intern(), it checks if this value is already in the String Pool. If not, it adds the value to the pool and returns a reference to that pooled instance.
After calling intern(), string3 points to the pooled copy of the string. The original heap instance, now without any active references, becomes eligible for garbage collection, reducing unnecessary memory usage.

Summary of Key Points

String Pool Optimization: The String Pool is crucial for saving memory by reusing literals.
Immutability: Immutability makes strings thread-safe and reliable but can result in additional heap objects when modifying strings.
Garbage Collection: Unreferenced literals in the pool are not garbage-collected, but unused heap-based strings are.

By understanding and leveraging these principles, Java developers can write more memory-efficient and performant code.

Happy Coding!

Strings: String Pool and Memory Management in Java

Arshi Saxena — Tue, 05 Nov 2024 12:03:29 +0000

Understanding how Java handles strings is essential, especially since strings are immutable and frequently used. In this article, we’ll explore Java’s String Pool, memory management for strings, and best practices to ensure efficient string handling.

Why String Handling Matters in Java

Java treats strings differently from other objects due to two key reasons:

Immutability: Strings are immutable, meaning once created, their value cannot be changed. This allows for thread safety and enhances performance, as multiple references can safely point to the same string.
String Pool: Java maintains a String Pool, a dedicated memory area in Heap for storing string literals, which makes string handling more memory-efficient.

What is the String Pool?

When you create a string using a literal (e.g., String str = "Hello";), Java first checks if "Hello" already exists in the String Pool:

If it exists, Java reuses the reference, making the operation memory-efficient.
If it doesn’t exist, Java adds "Hello" to the pool.

This process minimizes memory usage by storing only one copy of each literal, making the String Pool a crucial optimization feature for applications with many string references.

Example

String str1 = "Hello"; // Stored in String Pool
String str2 = "Hello"; // Reuses the "Hello" reference in the String Pool
System.out.println(str1 == str2); // Outputs: true

Takeaway: Using string literals leverages the String Pool, which conserves memory by reusing references.

Heap vs. String Pool

Creating strings with the new keyword (e.g., new String("Hello")) bypasses the String Pool and places the string directly in the Heap.

New String Objects in Heap: When new is used, Java allocates a new string in Heap memory, even if the same value exists in the String Pool.

Example

String str1 = "Hello"; // Stored in String Pool
String str2 = new String("Hello"); // Stored in Heap

// different memory locations
System.out.println(str1 == str2); // Outputs: false
System.out.println(str1.equals(str2)); // Outputs: true (same value)

Interning Strings with `intern()`

Java provides an intern() method to place a string explicitly in the String Pool. If the string doesn’t already exist in the pool, intern() adds it. If it does, intern() returns the existing reference.

Why Use `intern()`?

Memory Efficiency: intern() is helpful when working with dynamically created strings that need pooling. It can prevent duplicate storage, particularly in cases where multiple dynamically generated strings have the same content.
Careful Use: Unnecessary calls to intern() can create extra Heap objects and reduce performance. It’s best used when specific strings need to be in the String Pool.

Example of `intern()` with Detailed Steps

Consider the following code:

String word = new String("Word").intern();

Execution:

Since new is used, "Word" is first created in the Heap.
The intern() method then checks if "Word" exists in the String Pool.
- If not, it creates a new entry in the String Pool.
- If it does, it reuses the existing reference.
After this, there are now two occurrences of "Word"—one in the Heap and one in the String Pool.
Since the Heap object is no longer referenced, it becomes eligible for garbage collection.

Key Insight: Using new String() followed by intern() uses additional Heap space temporarily, resulting in less efficient memory usage. A better approach is to initialize strings directly with literals to avoid unnecessary Heap allocation.

Better approach

String word = "Word"; // Directly stores in the String Pool

Best Practice: Use string literals wherever possible, and rely on intern() sparingly, especially if you’re sure a particular string is frequently reused and dynamically created.

Conclusion

In Java, understanding how strings are stored and managed can lead to more efficient code. By leveraging the String Pool and adhering to best practices for string handling, you can optimize memory usage and application performance.

Stay tuned for the next post in this series, where we’ll dive deeper into immutability and common methods for working with strings!

Happy Coding!

Exploring Nuances of the Java Scanner Class

Arshi Saxena — Mon, 04 Nov 2024 08:05:12 +0000

The Scanner class in Java is a powerful tool for taking user input. However, it comes with some lesser-known quirks that can trip up developers, especially when using different input types. Here’s a dive into some key nuances and solutions to common issues.

1. Taking Multiline Input with `nextLine()`

The Scanner class’s nextLine() method is essential for reading multiline input. Unlike next(), which only reads until a space, nextLine() reads until a newline, making it perfect for inputs that contain spaces.

System.out.println("Enter Customer's Full Name, Email, Age, and Credit Limit");
Scanner sc = new Scanner(System.in);

// Using nextLine() for full name (handles spaces) and next() for single-word inputs
ScannerInput customer = new ScannerInput(sc.nextLine(), sc.next(), sc.nextInt(), sc.nextDouble());

In this example, nextLine() is used to capture a full name with spaces. This lets us handle inputs like “Arshi Saxena” without splitting them into separate tokens.

2. The Newline Buffer Problem

When you use nextInt(), next(), or nextDouble() before nextLine(), any newline (\n) left in the buffer can interfere with your input flow. For instance:

System.out.println("Enter a number:");
int number = sc.nextInt();
sc.nextLine(); // Clear the newline from the buffer

System.out.println("Enter a sentence:");
String sentence = sc.nextLine();

Here, sc.nextLine() is added after sc.nextInt() to clear the newline character, preventing it from being immediately read as input by the following nextLine().

3. Best Practices for Using Scanner in Mixed Input Scenarios

When combining different types of inputs, remember to manage the buffer carefully:

Use nextLine() immediately after any method like nextInt() or nextDouble() to consume leftover newline characters.
Consider creating separate methods for different input types to avoid confusion.
Always close Scanner instances after use to free resources.

Example: Solving the Newline Buffer Problem

Here’s a practical example that demonstrates both nextLine() usage and clearing the buffer:

Scanner sc = new Scanner(System.in);

System.out.println("Enter Customer's Full Name, Email, Age, and Credit Limit");
ScannerInput c1 = new ScannerInput(sc.nextLine(), sc.next(), sc.nextInt(), sc.nextDouble());

System.out.println("Enter Alias:");
sc.nextLine(); // Clear buffer
String alias = sc.nextLine();

System.out.println("Alias is " + alias);

Conclusion

These tips will help ensure smoother input handling and minimize unexpected behavior in your applications.

Happy Coding!

Polymorphism: Decoding Method Overriding in Java

Arshi Saxena — Fri, 01 Nov 2024 08:35:38 +0000

Method Overriding is one of the core concepts of polymorphism in Java, allowing a subclass to provide a specific implementation of a method already defined in its superclass. This powerful feature helps achieve runtime polymorphism and enables dynamic method dispatch. In this post, we’ll dive into the essential concepts, rules, and real-world examples to understand method overriding thoroughly.

What is Method Overriding?

Method overriding occurs when a subclass redefines a method from its superclass with the same method signature (same name, parameters, and return type or a covariant return type). Unlike method overloading, which is resolved at compile-time, method overriding achieves runtime polymorphism, where the actual method called depends on the object's runtime type.

1. Rules of Method Overriding

1. Method Signature Consistency:

The method name and parameter list in the subclass must exactly match the method in the superclass.

2. Return Type and Covariant Return Types:

The return type must either be the same or a covariant type (a subtype of the original return type in the superclass).

3. Access Modifiers:

A method in a subclass cannot have a more restrictive access level than the method in the superclass (e.g., if the superclass method is protected, the subclass cannot make it private).

Public > Protected > Default (Package-Private) > Private

4. Method Visibility:

Private methods cannot be overridden. Instead, if redefined in the subclass, they are treated as entirely new methods.

Example: Basic Method Overriding

package oops.polymorphism;

// Base class
public class MethodOverridingParent {

    // Private Methods CANNOT be overridden
    private String getName() {
        return "Hello";
    }

    // Display method to be overridden (Access Modifier: default)
    void display() {
        System.out.println("Parent Method Called");
    }

    // Return type is Number (parent class of Integer, Double, etc.)
    public Number getCount() {
        return 20;
    }
}

In MethodOverridingParent, only display() and getCount() can be overridden by subclasses, as they are accessible beyond the parent class. However, getName() is private, so it cannot be overridden since it isn’t inherited by subclasses.

2. Method Overriding in Child Class

package oops.polymorphism;

public class MethodOverridingChild extends MethodOverridingParent {

    // Access Level Increased; Default -> Protected
    @Override
    protected void display() {
        System.out.println("Child Method Called");
    }

    public static void main(String[] args) {

        // Calling Parent Class Method
        MethodOverridingParent parent = new MethodOverridingParent();
        parent.display(); // Output: Parent Method Called

        // Calling Child Class Overridden Method - Runtime Polymorphism
        MethodOverridingParent child = new MethodOverridingChild();
        child.display(); // Output: Child Method Called
    }
}

Explanation: Since display() is overridden in the subclass MethodOverridingChild, invoking display() on a MethodOverridingChild instance calls the child’s version. This is runtime polymorphism in action.

3. Covariant Return Types: A Practical Example

Java’s support for covariant return types allows the subclass to return a type that’s more specific than the superclass’s return type. This approach follows the Liskov Substitution Principle in the SOLID principles, enhancing code flexibility.

package oops.polymorphism;

// Demonstrating covariant return type
public class CovariantReturnType extends MethodOverridingParent {

    // Parent method's Return type is Number
    // Since Integer is a subclass of Number, covariance is achieved
    // Since Base class' method is public, subclass has to use public
    @Override
    public Integer getCount() {
        return 40;
    }

    public static void main(String[] args) {
        CovariantReturnType type = new CovariantReturnType();
        System.out.println(type.getCount()); // Output: 40
    }
}

Explanation: In CovariantReturnType, getCount() overrides the parent’s method by returning an Integer, a subtype of Number, demonstrating covariant return types. The method remains public because Java requires that the access level of an overridden method can’t be reduced.

Method Overriding vs. Method Overloading

Method Overriding enables dynamic polymorphism and operates in inheritance hierarchies.
Method Overloading is a form of static polymorphism achieved within the same class by having different parameter types or numbers.

When to Use Method Overriding

Dynamic Method Resolution: Overriding methods are resolved at runtime based on the object type, providing greater flexibility.
Extending Behavior: Subclasses can modify or extend the functionality of superclass methods.

Conclusion

By understanding and applying method overriding, we can build more flexible, reusable, and polymorphic Java applications that adhere to object-oriented programming principles.

Happy Coding!

DEV Community: Arshi Saxena

Mastering SOLID Principles for Java Interviews

Why SOLID Principles Matter

The SOLID Principles Unpacked

1. Single Responsibility Principle (SRP)

2. Open/Closed Principle (OCP)

3. Liskov Substitution Principle (LSP)

4. Interface Segregation Principle (ISP)

5. Dependency Inversion Principle (DIP)

Why SOLID is Key for Java Interviews

Closing Thoughts

Related Posts

Sorting Smarts in Java: TreeSet and TreeMap

TreeSet: A Set That Sorts

Key Characteristics of TreeSet:

Example 1: Natural Ordering with TreeSet

Output:

Explanation:

Example 2: Custom Ordering with TreeSet

Output:

Explanation:

TreeMap: A Map That Sorts

Key Characteristics of TreeMap:

Example 1: Natural Ordering with TreeMap

Output

Code Explanation

TreeMap: Custom Ordering with Comparator

Example: TreeMap with Custom Ordering (By Category and Price)

Output

Code Explanation

Conclusion

Key Takeaways:

Related Posts

Sorting Smarts in Java: Comparable and Comparator

Natural Ordering: The Comparable Interface

Key Characteristics of Comparable:

Example: Sorting by ID

Output

Code Explanation

Custom Ordering: The Comparator Interface

Key Characteristics of Comparator:

Example: Sorting by category and price

Output

Code Explanation

Comparing Comparable and Comparator

Key Takeaways

Related Posts

Demystifying hashCode() and equals(): The Backbone of Java Hash Collections

Introduction

How Elements Are Stored in a HashMap

Visualization

Why hashCode() and equals() Matter

How They Work Together

The Contract Between hashCode() and equals()

Implementation Example

What’s Happening in the Code?

Best Practices and Takeaways

Key Takeaways

Related Posts

StringBuilder vs StringBuffer in Java

Key Differences: StringBuilder vs. StringBuffer

1. StringBuilder: The Efficient Choice for Single-Threaded Environments

Example: Demonstrating Thread Unsafety in StringBuilder

2. StringBuffer: The Safe Option for Multi-Threaded Environments

Example: Thread Safety in StringBuffer

Choosing the Right Class

Conclusion

Related Posts

Strings: Understanding Mutability and Immutability

1. The Immutability of String in Java

2. Using String in Mutable Scenarios: Drawbacks

3. Mutable Alternatives: StringBuilder and StringBuffer

Using StringBuilder for Efficient Mutability

Key Points to Remember

Conclusion

Related Posts

Strings: Checking for Palindromes

Problem Statement

Solution Overview

Key Points of the Approach:

Example: Sorting by `category` and `price`

Why `hashCode()` and `equals()` Matter

The Contract Between `hashCode()` and `equals()`

1. `StringBuilder`: The Efficient Choice for Single-Threaded Environments

Example: Demonstrating Thread Unsafety in `StringBuilder`

2. `StringBuffer`: The Safe Option for Multi-Threaded Environments

Example: Thread Safety in `StringBuffer`

1. The Immutability of `String` in Java

3. Mutable Alternatives: `StringBuilder` and `StringBuffer`

1. `equalsIgnoreCase()`: Case-Insensitive Comparison

2. `toLowerCase()` and `toUpperCase()`: Case Conversion

3. `startsWith()` and `endsWith()`: Check String Boundaries

4. `toCharArray()`: Convert String to Character Array

5. `charAt()`, `indexOf()`, and `lastIndexOf()`: Character Search

6. `contains()`: Substring Presence Check

7. `substring()`: Extracting Parts of a String

8. `replace()`: Replacing Characters or Substrings

9. `split()`: Splitting Strings into Parts

10. `compareTo()`: Lexicographical Comparison

11. `isBlank()` and `isEmpty()`: Check String State

12. `matches()`: Regular Expression Matching

13. `trim()`: Removing Extra Whitespaces

Interning Strings with `intern()`

Why Use `intern()`?

Example of `intern()` with Detailed Steps

1. Taking Multiline Input with `nextLine()`