Home » Tutorials » Misc
Category:

Misc

Misc

Java WeakHashMap Tutorial with Examples

written by 75ypsaw71

The WeakHashMap class in Java is a specialized type of Map where keys are weak references, meaning they can be automatically garbage collected when no longer referenced elsewhere.

This makes WeakHashMap useful for caching and storing temporary data that should not prevent objects from being garbage collected.

Key Features of WeakHashMap

✔ Uses weak references for keys (values remain strong references).
✔ Entries are removed automatically when keys are garbage collected.
✔ Good for caching, memory-sensitive applications, and reducing memory leaks.
✔ Not thread-safe (use Collections.synchronizedMap() for synchronization).

1. Creating and Using a WeakHashMap

A WeakHashMap works similarly to a HashMap, but the keys are weakly referenced.

Example: Basic WeakHashMap Usage

import java.util.WeakHashMap;

public class WeakHashMapExample {
    public static void main(String[] args) {
        WeakHashMap<String, String> weakMap = new WeakHashMap<>();

        // Creating keys as String objects
        String key1 = new String("A");
        String key2 = new String("B");
        String key3 = new String("C");

        // Adding key-value pairs
        weakMap.put(key1, "Apple");
        weakMap.put(key2, "Banana");
        weakMap.put(key3, "Cherry");

        System.out.println("Before Garbage Collection: " + weakMap);

        // Nullifying the strong references to keys
        key1 = null;
        key2 = null;

        // Hinting the JVM to run Garbage Collector
        System.gc();

        // Waiting a bit for GC to complete
        try { Thread.sleep(1000); } catch (InterruptedException e) { }

        System.out.println("After Garbage Collection: " + weakMap);
    }
}

Expected Output

Before Garbage Collection: {A=Apple, B=Banana, C=Cherry}
After Garbage Collection: {C=Cherry}

Explanation

  • key1 and key2 were weakly referenced and after setting them to null, the garbage collector removed them from the map.
  • key3 was still referenced, so it remained in the WeakHashMap.

2. Comparing WeakHashMap with HashMap

Unlike WeakHashMap, a HashMap holds strong references to keys, preventing them from being garbage collected.

Example: Difference Between HashMap and WeakHashMap

import java.util.HashMap;
import java.util.WeakHashMap;

public class HashMapVsWeakHashMap {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        WeakHashMap<String, String> weakHashMap = new WeakHashMap<>();

        String key1 = new String("Key1");
        String key2 = new String("Key2");

        hashMap.put(key1, "Value1");
        weakHashMap.put(key2, "Value2");

        System.out.println("Before GC:");
        System.out.println("HashMap: " + hashMap);
        System.out.println("WeakHashMap: " + weakHashMap);

        // Nullifying references
        key1 = null;
        key2 = null;

        // Triggering Garbage Collection
        System.gc();

        // Waiting a bit
        try { Thread.sleep(1000); } catch (InterruptedException e) { }

        System.out.println("After GC:");
        System.out.println("HashMap: " + hashMap);
        System.out.println("WeakHashMap: " + weakHashMap);
    }
}

Expected Output

Before GC:
HashMap: {Key1=Value1}
WeakHashMap: {Key2=Value2}

After GC:
HashMap: {Key1=Value1}
WeakHashMap: {}

Explanation

  • In HashMap, Key1 was strongly referenced, so it was not garbage collected.
  • In WeakHashMap, Key2 was weakly referenced, so it got removed automatically.

3. When to Use WeakHashMap

✔ Caching Data: If you want objects to be automatically removed when no longer used.
✔ Reducing Memory Leaks: Helps avoid unintentional retention of objects.
✔ Temporary Metadata Storage: Suitable for short-lived objects.

Example: Using WeakHashMap for Caching

import java.util.WeakHashMap;

class ExpensiveObject {
    private String name;
    public ExpensiveObject(String name) { this.name = name; }
    public String toString() { return name; }
}

public class WeakHashMapCache {
    public static void main(String[] args) {
        WeakHashMap<ExpensiveObject, String> cache = new WeakHashMap<>();

        ExpensiveObject obj1 = new ExpensiveObject("Object1");
        ExpensiveObject obj2 = new ExpensiveObject("Object2");

        cache.put(obj1, "Cached Data 1");
        cache.put(obj2, "Cached Data 2");

        System.out.println("Before GC: " + cache);

        // Removing strong reference
        obj1 = null;

        System.gc();

        try { Thread.sleep(1000); } catch (InterruptedException e) { }

        System.out.println("After GC: " + cache);
    }
}

Expected Output

Before GC: {Object1=Cached Data 1, Object2=Cached Data 2}
After GC: {Object2=Cached Data 2}

Explanation

  • obj1 was removed from the map after GC because it was weakly referenced.
  • obj2 remained because it was still referenced.

4. WeakHashMap with Synchronization

Since WeakHashMap is not thread-safe, it can be synchronized using Collections.synchronizedMap().

import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;

public class SynchronizedWeakHashMap {
    public static void main(String[] args) {
        Map<String, String> syncWeakMap = Collections.synchronizedMap(new WeakHashMap<>());

        syncWeakMap.put("Key1", "Value1");
        syncWeakMap.put("Key2", "Value2");

        System.out.println(syncWeakMap);
    }
}

Explanation

  • Collections.synchronizedMap() makes WeakHashMap thread-safe for concurrent access.

5. Comparing WeakHashMap with Other Maps

Feature HashMap WeakHashMap LinkedHashMap TreeMap
Ordering No order No order Insertion order Sorted order
Null Keys ✅ Yes ✅ Yes ✅ Yes ❌ No
Memory Usage High (Strong References) Low (Weak References) Medium High (Sorted)
Automatic Removal ❌ No ✅ Yes (Garbage Collection) ❌ No ❌ No
Thread-Safe ❌ No ❌ No ❌ No ❌ No

Conclusion

  • WeakHashMap automatically removes unused keys when garbage collected.
  • Ideal for caching, temporary storage, and memory-sensitive applications.
  • Unlike HashMap, it does not prevent objects from being garbage collected.
  • Not thread-safe but can be synchronized using Collections.synchronizedMap().
  • If you need ordered keys, use LinkedHashMap, and if sorting is needed, use TreeMap.

Using WeakHashMap wisely can help optimize memory usage and reduce memory leaks, making it a useful tool in Java development.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Java LinkedHashMap Tutorial with Examples

written by 75ypsaw71

The LinkedHashMap class in Java is a part of the Java Collections Framework and extends HashMap while maintaining the insertion order of elements. It is useful when you need a key-value mapping with predictable iteration order.

In this tutorial, we will cover:

1. Understanding LinkedHashMap

Key Features:

✔ Maintains insertion order of elements
✔ Allows one null key and multiple null values
✔ Not synchronized (use Collections.synchronizedMap() for thread safety)
✔ Provides constant-time performance for insertions and lookups

Class Declaration:

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

2. Creating and Initializing a LinkedHashMap

You can create a LinkedHashMap using different constructors.

Example: Creating a Simple LinkedHashMap

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // Creating a LinkedHashMap with default capacity
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();

        // Adding elements
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        System.out.println("LinkedHashMap: " + map);
    }
}

Output:

LinkedHashMap: {1=Apple, 2=Banana, 3=Cherry}

Example: Creating a LinkedHashMap with Initial Capacity

LinkedHashMap<Integer, String> map = new LinkedHashMap<>(16, 0.75f);
  • 16: Initial capacity
  • 0.75f: Load factor (default: 0.75)

3. Accessing and Modifying Elements

You can access, update, and modify elements using standard Map methods.

Example: Get, Replace, and Modify Elements

import java.util.LinkedHashMap;

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> scores = new LinkedHashMap<>();
        
        // Adding elements
        scores.put("Alice", 85);
        scores.put("Bob", 92);
        scores.put("Charlie", 78);

        // Accessing a value
        System.out.println("Bob's Score: " + scores.get("Bob"));

        // Updating a value
        scores.put("Alice", 90);
        System.out.println("Updated Scores: " + scores);
    }
}

Output:

Bob's Score: 92
Updated Scores: {Alice=90, Bob=92, Charlie=78}

4. Iterating Over a LinkedHashMap

You can iterate over keys, values, or entries using different approaches.

Example: Iterating Using a forEach Loop

import java.util.LinkedHashMap;
import java.util.Map;

public class IterateLinkedHashMap {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        map.put(101, "Java");
        map.put(102, "Python");
        map.put(103, "JavaScript");

        // Iterating using forEach
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
    }
}

Output:

101 -> Java
102 -> Python
103 -> JavaScript

Example: Iterating Using Java 8 forEach

map.forEach((key, value) -> System.out.println(key + " -> " + value));

5. Maintaining Access Order for Caching

By default, LinkedHashMap maintains insertion order. However, you can configure it to maintain access order by setting the accessOrder flag to true.

Example: Creating an LRU Cache Using LinkedHashMap

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int maxSize;

    public LRUCache(int maxSize) {
        super(maxSize, 0.75f, true); // Access-order enabled
        this.maxSize = maxSize;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > maxSize; // Remove oldest entry when size exceeds maxSize
    }

    public static void main(String[] args) {
        LRUCache<Integer, String> cache = new LRUCache<>(3);

        cache.put(1, "A");
        cache.put(2, "B");
        cache.put(3, "C");

        // Access key 1 (moves it to the end)
        cache.get(1);

        // Insert a new element (removes least recently used entry, which is key 2)
        cache.put(4, "D");

        System.out.println("LRU Cache: " + cache);
    }
}

Output:

LRU Cache: {3=C, 1=A, 4=D}

In this example, the least recently used element is automatically removed when a new entry is added beyond capacity.

6. Removing Elements

Example: Removing Entries

map.remove(102); // Removes entry with key 102
map.clear(); // Removes all entries

7. Checking for Keys and Values

Example: Check Existence of Keys and Values

System.out.println(map.containsKey(101)); // true
System.out.println(map.containsValue("Python")); // false

8. Using LinkedHashMap with Generics

You can use LinkedHashMap with custom objects as keys and values.

Example: Using Custom Class as Key

import java.util.LinkedHashMap;
import java.util.Objects;

class Student {
    String name;
    int id;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return id == student.id && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

public class CustomLinkedHashMap {
    public static void main(String[] args) {
        LinkedHashMap<Student, Integer> studentScores = new LinkedHashMap<>();

        studentScores.put(new Student(1, "Alice"), 85);
        studentScores.put(new Student(2, "Bob"), 90);

        studentScores.forEach((student, score) ->
                System.out.println(student.name + "'s Score: " + score));
    }
}

9. Comparing LinkedHashMap vs HashMap vs TreeMap

Feature HashMap LinkedHashMap TreeMap
Ordering Unordered Insertion Order Sorted Order
Performance Fastest Slightly Slower Slower (Sorted)
Use Case General Purpose Ordered Data Sorted Data

Conclusion

  • LinkedHashMap is useful when ordering of keys matters.
  • It provides O(1) time complexity for get() and put() operations.
  • It can be used for caching (LRU implementations).
  • It maintains either insertion order or access order (if configured).

By leveraging LinkedHashMap, you can efficiently manage ordered key-value mappings while ensuring predictable iteration order.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Java Interrupting a Thread Tutorial with Examples

written by 75ypsaw71

In Java, interrupting a thread is a way of signaling a thread to stop its current execution.

While threads do not stop immediately when interrupted, they can respond to the interruption signal and stop gracefully by checking their interrupt status or handling the InterruptedException.

In this tutorial, we will cover:

  1. What is Thread Interruption in Java?
  2. Using interrupt() to Signal a Thread
  3. Checking the Interrupt Status
  4. Handling InterruptedException
  5. Best Practices for Handling Thread Interruption
  6. Examples and Use Cases

Let’s explore each concept with examples.

1. What is Thread Interruption in Java?

In Java, thread interruption is a mechanism to signal a thread that it should stop its current work. However, thread interruption does not stop the thread immediately.

Instead, it is up to the thread to regularly check its interrupt status or handle an InterruptedException to stop gracefully.

Java threads have a flag called the interrupt flag, which is set when interrupt() is called on the thread.

The thread can check this flag by using methods like Thread.interrupted() or isInterrupted() to decide if it should stop or continue its execution.

2. Using interrupt() to Signal a Thread

The interrupt() method is used to signal a thread that it has been interrupted. This method does not forcefully terminate the thread but sets the interrupt flag to true, which can be checked or handled within the thread.

Example 1: Signaling a Thread Using interrupt()

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running...");

        for (int i = 1; i <= 10; i++) {
            System.out.println("Working on task " + i);

            // Simulate some work with sleep
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted during sleep.");
                return;  // Stop execution when interrupted
            }
        }

        System.out.println("Thread completed.");
    }
}

public class InterruptExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        try {
            // Give the thread some time to run
            Thread.sleep(3000);  // Main thread sleeps for 3 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Interrupt the thread after 3 seconds
        thread.interrupt();
        System.out.println("Thread interrupt signal sent.");
    }
}

Output:

Thread is running...
Working on task 1
Working on task 2
Working on task 3
Thread was interrupted during sleep.
Thread interrupt signal sent.

Explanation:

  • The interrupt() method sends a signal to the thread. The thread does not stop immediately but can check the interrupt status and handle it.
  • In the example, the thread is interrupted during its sleep(), and the InterruptedException is caught. The thread then terminates gracefully.

3. Checking the Interrupt Status

You can check a thread's interrupt status using either Thread.interrupted() or isInterrupted().

  • Thread.interrupted(): Checks if the current thread has been interrupted and clears the interrupt flag after checking.
  • isInterrupted(): Checks if the thread has been interrupted without clearing the flag.

Example 2: Checking the Interrupt Status Using isInterrupted()

class MyTask implements Runnable {
    public void run() {
        System.out.println("Thread is running...");

        for (int i = 1; i <= 5; i++) {
            System.out.println("Task " + i);

            // Check if the thread has been interrupted
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("Thread was interrupted. Exiting...");
                break;
            }

            // Simulate some work with sleep
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted during sleep.");
                return;
            }
        }

        System.out.println("Thread completed.");
    }
}

public class InterruptCheckExample {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTask());
        thread.start();

        try {
            Thread.sleep(2000);  // Main thread sleeps for 2 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Interrupt the thread after 2 seconds
        thread.interrupt();
    }
}

Output:

Thread is running...
Task 1
Task 2
Thread was interrupted. Exiting...
Thread was interrupted during sleep.

Explanation:

  • The isInterrupted() method is used to check if the thread has been interrupted.
  • When the interrupt flag is set, the thread checks this status and exits the loop early.

4. Handling InterruptedException

When a thread is interrupted during a blocking operation like Thread.sleep(), wait(), or join(), it throws an InterruptedException. This exception must be handled inside the thread to ensure the thread responds to interruptions.

Example 3: Handling InterruptedException in Thread

class BlockingTask implements Runnable {
    public void run() {
        System.out.println("Thread is performing a blocking operation...");

        try {
            // Simulating a long operation with sleep
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            System.out.println("Thread was interrupted during a blocking operation.");
            return;  // Stop execution when interrupted
        }

        System.out.println("Thread finished blocking operation.");
    }
}

public class InterruptBlockingExample {
    public static void main(String[] args) {
        Thread thread = new Thread(new BlockingTask());
        thread.start();

        try {
            Thread.sleep(2000);  // Main thread sleeps for 2 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Interrupt the thread while it's performing a blocking operation
        thread.interrupt();
        System.out.println("Interrupt signal sent to the thread.");
    }
}

Output:

Thread is performing a blocking operation...
Interrupt signal sent to the thread.
Thread was interrupted during a blocking operation.

Explanation:

  • The thread is interrupted while it is sleeping (Thread.sleep()), and the InterruptedException is caught. The thread then stops its execution.

5. Best Practices for Handling Thread Interruption

  • Check for Interruption Regularly: In long-running tasks or loops, make sure to check the interrupt status regularly using isInterrupted() or Thread.interrupted() to handle interruptions gracefully. 
    if (Thread.currentThread().isInterrupted()) {
    // Handle the interruption, e.g., clean up resources or stop the task
    break;
}
  • Respond to InterruptedException: When a thread is interrupted during a blocking operation, such as sleep() or wait(), it should handle the InterruptedException by cleaning up and stopping the task. 
    try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // Handle the exception and stop the thread
    Thread.currentThread().interrupt();  // Preserve the interrupt status
    return;
}
  • Preserve the Interrupt Status: If you catch an InterruptedException, it's a good practice to call Thread.currentThread().interrupt() to restore the interrupt flag if you intend to propagate the interruption.

6. Examples and Use Cases

Example 4: Gracefully Stopping a Long-Running Task

Let’s say you have a long-running task that should stop when an interrupt signal is received. You can check for interruptions in each iteration of the task.

class LongRunningTask implements Runnable {
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("Processing task " + i);

            // Check for interrupt signal
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("Thread was interrupted. Stopping task...");
                break;
            }

            // Simulate a time-consuming operation
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted during sleep. Exiting...");
                return;
            }
        }

        System.out.println("Task completed.");
    }
}

public class LongRunningTaskExample {
    public static void main(String[] args) {
        Thread thread = new Thread(new LongRunningTask());
        thread.start();

        try {
            Thread.sleep(4000);  // Main thread sleeps for 4 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Interrupt the thread
        thread.interrupt();
    }
}

Output:

Processing task 1
Processing task 2
Processing task 3
Processing task 4
Thread was interrupted. Stopping task...

Explanation:

  • The thread processes tasks in a loop, checking the interrupt flag during each iteration.
  • When the interrupt signal is sent, the thread stops gracefully before completing all tasks.

Summary of Key Concepts for Thread Interruption

Concept Description
interrupt() Signals a thread that it has been interrupted by setting the interrupt flag to true.
isInterrupted() Checks if the current thread has been interrupted without clearing the interrupt flag.
Thread.interrupted() Checks if the current thread has been interrupted and clears the interrupt flag.
InterruptedException Thrown when a thread is interrupted during a blocking operation (like sleep(), wait(), or join()).
Best Practice Regularly check for interruptions and handle InterruptedException properly by cleaning up and stopping the task.
Restoring Interrupt Status If you catch InterruptedException, call Thread.currentThread().interrupt() to restore the interrupt status.

Conclusion

In this tutorial, we explored how to interrupt threads in Java using the interrupt() method and handle thread interruptions gracefully.

We covered:

  • The use of the interrupt() method to signal threads.
  • How to check the interrupt status using isInterrupted() and Thread.interrupted().
  • Handling InterruptedException when a thread is performing a blocking operation.
  • Best practices for handling thread interruptions in long-running tasks.
0 comment
0 FacebookTwitterPinterestEmail
Misc

Reentrant Monitors in Java tutorial with code examples

written by 75ypsaw71

In Java, monitors (also known as intrinsic locks) are used to control access to critical sections of code that should not be executed by multiple threads simultaneously. These monitors ensure mutual exclusion and thread synchronization.

A Reentrant Monitor allows a thread that has already acquired a lock to re-enter the same synchronized block or method it previously entered.

This is essential when a thread needs to acquire the same lock multiple times, such as when it calls methods within synchronized methods or re-enters synchronized blocks.

In Java, the concept of reentrant monitors is built into the synchronized keyword. Additionally, Java provides a more flexible class, ReentrantLock, from the java.util.concurrent.locks package, which allows explicit lock acquisition and release with advanced features like fairness policies and interruptibility.

1. Using synchronized as a Reentrant Monitor

In Java, every object has an intrinsic lock, and when a thread enters a synchronized method or block, it acquires the lock. If the same thread attempts to enter another synchronized block that requires the same lock, it can re-enter (hence “reentrant”) without deadlocking.

Example 1: Reentrant Synchronization with synchronized

class ReentrantExample {
    public synchronized void methodA() {
        System.out.println("Inside method A");
        methodB(); // Re-entrant lock: This thread will not block here.
    }

    public synchronized void methodB() {
        System.out.println("Inside method B");
    }
}

public class ReentrantMonitorExample1 {
    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

Output:

Inside method A
Inside method B

Explanation:

The method methodA() is synchronized, meaning it requires the current thread to acquire the object’s intrinsic lock.
When methodB() is called within methodA(), the thread can re-enter the lock it already holds, demonstrating reentrant behavior.

2. ReentrantLock: Advanced Reentrant Monitor

The ReentrantLock class is part of the java.util.concurrent.locks package and provides additional features compared to the synchronized keyword:

You can explicitly lock and unlock.
It supports interruptible and timed lock acquisition.
It allows fairness policies (to ensure locks are granted in order of request).

Example 2: Using ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

class ReentrantLockExample {
    private ReentrantLock lock = new ReentrantLock();

    public void methodA() {
        lock.lock(); // Acquire the lock
        try {
            System.out.println("Inside method A");
            methodB(); // Re-entrant lock: This thread can acquire the lock again.
        } finally {
            lock.unlock(); // Release the lock
        }
    }

    public void methodB() {
        lock.lock(); // Acquire the lock
        try {
            System.out.println("Inside method B");
        } finally {
            lock.unlock(); // Release the lock
        }
    }
}

public class ReentrantMonitorExample2 {
    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        example.methodA();
    }
}

Output:

Inside method A
Inside method B

Explanation:

The ReentrantLock allows the same thread to re-enter the lock when it calls methodB() from within methodA().
The lock.lock() method acquires the lock, and lock.unlock() releases it.
Reentrant locks ensure that a thread that has already acquired the lock can reacquire it.

3. Preventing Deadlock with Reentrant Monitors

Without reentrant locks, recursive calls to synchronized methods could lead to deadlock.

Here’s an example where the absence of reentrancy would cause deadlock, but reentrant monitors allow the thread to proceed safely.

Example 3: Recursive Reentrant Lock

class ReentrantRecursiveExample {
    public synchronized void recursiveMethod(int count) {
        if (count > 0) {
            System.out.println("Recursive count: " + count);
            recursiveMethod(count - 1); // Re-enter the same lock
        }
    }
}

public class ReentrantMonitorExample3 {
    public static void main(String[] args) {
        ReentrantRecursiveExample example = new ReentrantRecursiveExample();
        example.recursiveMethod(5); // Recursively call the method with a countdown
    }
}

Output:

Recursive count: 5
Recursive count: 4
Recursive count: 3
Recursive count: 2
Recursive count: 1

Explanation:

The recursiveMethod() calls itself recursively, and since it's synchronized, the current thread re-enters the same lock multiple times.
Without a reentrant monitor, this would result in a deadlock. However, with reentrancy, the same thread can reacquire the lock as needed.

4. Fairness with ReentrantLock

The ReentrantLock class supports a fairness policy. When fairness is enabled, locks are granted in the order they were requested, preventing “starvation” of threads.

Example 4: Using Fair ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

class FairReentrantLockExample {
    private ReentrantLock lock = new ReentrantLock(true); // Fair lock

    public void accessResource(String threadName) {
        lock.lock(); // Acquire the lock
        try {
            System.out.println(threadName + " has acquired the lock.");
            Thread.sleep(1000); // Simulate some work
        } catch (InterruptedException e) {
            System.out.println(e);
        } finally {
            System.out.println(threadName + " is releasing the lock.");
            lock.unlock(); // Release the lock
        }
    }
}

public class ReentrantMonitorExample4 {
    public static void main(String[] args) {
        FairReentrantLockExample example = new FairReentrantLockExample();
        Runnable task = () -> example.accessResource(Thread.currentThread().getName());

        // Start multiple threads
        Thread t1 = new Thread(task, "Thread 1");
        Thread t2 = new Thread(task, "Thread 2");
        Thread t3 = new Thread(task, "Thread 3");

        t1.start();
        t2.start();
        t3.start();
    }
}

Output:

Thread 1 has acquired the lock.
Thread 1 is releasing the lock.
Thread 2 has acquired the lock.
Thread 2 is releasing the lock.
Thread 3 has acquired the lock.
Thread 3 is releasing the lock.

Explanation:

The ReentrantLock is created with the fairness flag set to true, which ensures that threads acquire the lock in the order they requested it.
This prevents thread starvation, where one thread might monopolize the lock while other threads are waiting.

5. Try Locking with ReentrantLock

The ReentrantLock class provides a tryLock() method, which allows a thread to attempt to acquire the lock without blocking indefinitely. This is useful when you don't want a thread to wait forever for a lock.

Example 5: Using tryLock()

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

class TryLockExample {
    private ReentrantLock lock = new ReentrantLock();

    public void accessResource(String threadName) {
        try {
            if (lock.tryLock(500, TimeUnit.MILLISECONDS)) { // Try to acquire the lock for 500ms
                try {
                    System.out.println(threadName + " has acquired the lock.");
                    Thread.sleep(1000); // Simulate some work
                } finally {
                    System.out.println(threadName + " is releasing the lock.");
                    lock.unlock(); // Release the lock
                }
            } else {
                System.out.println(threadName + " could not acquire the lock.");
            }
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

public class ReentrantMonitorExample5 {
    public static void main(String[] args) {
        TryLockExample example = new TryLockExample();
        Runnable task = () -> example.accessResource(Thread.currentThread().getName());

        // Start multiple threads
        Thread t1 = new Thread(task, "Thread 1");
        Thread t2 = new Thread(task, "Thread 2");

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

Output:

Thread 1 has acquired the lock.
Thread 2 could not acquire the lock.
Thread 1 is releasing the lock.

Explanation:

tryLock() allows the thread to attempt to acquire the lock without blocking indefinitely.
If the lock is not available within 500 milliseconds, the thread proceeds without acquiring the lock.

6. Using ReentrantLock with Conditions

The ReentrantLock class supports conditions via the Condition object. This allows threads to wait for specific conditions before proceeding, similar to Object.wait() and Object.notify().

Example 6: Using Condition with ReentrantLock

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

class ConditionExample {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean isConditionMet = false;

    public void waitForCondition() throws InterruptedException {
        lock.lock();
        try {
            while (!isConditionMet) {
                System.out.println("Waiting for the condition to be met...");
                condition.await(); // Wait for the condition
            }
            System.out.println("Condition met, proceeding...");
        } finally {
            lock.unlock();
        }
    }

    public void signalCondition() {
        lock.lock();
        try {
            isConditionMet = true;
            condition.signalAll(); // Signal all waiting threads
        } finally {
            lock.unlock();
        }
    }
}

public class ReentrantMonitorExample6 {
    public static void main(String[] args) {
        ConditionExample example = new ConditionExample();

        // Thread waiting for the condition
        Thread waiter = new Thread(() -> {
            try {
                example.waitForCondition();
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        });

        // Thread signaling the condition
        Thread signaler = new Thread(example::signalCondition);

        waiter.start();

        try {
            Thread.sleep(2000); // Simulate some delay before signaling
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        signaler.start();
    }
}

Output:

Waiting for the condition to be met...
Condition met, proceeding...

Explanation:

The Condition object is used to make the waitForCondition() thread wait until a specific condition is met.
The signaler thread calls signalCondition(), which changes the condition and wakes up the waiting thread.

Conclusion

In Java, reentrant monitors are an essential mechanism for controlling access to shared resources across multiple threads.

The built-in synchronized keyword provides basic reentrant locking functionality, while the ReentrantLock class from the java.util.concurrent.locks package offers more flexibility and features such as fairness policies, timed locking, and explicit lock handling.

Key points:

Reentrancy: A thread holding a lock can acquire it again (useful for recursive and nested lock acquisitions).
synchronized keyword: Automatically provides reentrancy, though it's implicit and has no extra features.
ReentrantLock: Provides explicit locking with features like fairness, timed locks, and conditions.
tryLock(): Useful for attempting to acquire a lock without blocking indefinitely.
Condition: Allows fine-grained control over thread communication and synchronization.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Joining Threads in Java tutorial with code examples

written by 75ypsaw71

In Java, joining threads allows one thread to wait for the completion of another thread before proceeding.

The Thread.join() method is crucial for ensuring that certain operations occur after other threads have finished executing.

This is especially useful in scenarios where you need to synchronize thread execution or coordinate the result of multiple threads.

The join() method blocks the calling thread until the thread on which join() was called terminates. There are three variations of the join() method:

join() – Waits indefinitely until the thread completes.
join(long millis) – Waits for the specified time (in milliseconds) for the thread to finish.
join(long millis, int nanos) – Waits for the specified time (in milliseconds and nanoseconds) for the thread to finish.

1. Basic Example of Thread.join()

In this first example, we will demonstrate how the main thread can wait for a secondary thread to complete using the join() method.

Example 1: Basic Join

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class JoinExample1 {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        try {
            thread.join(); // Main thread waits for thread to finish
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread has finished after child thread.");
    }
}

Output:

Thread: 1
Thread: 2
Thread: 3
Thread: 4
Thread: 5

Main thread has finished after child thread.

Explanation:

The join() method ensures that the main thread waits for the MyThread to complete before printing “Main thread has finished after child thread.”.
The main thread will only continue once the child thread has finished its execution.

2. Using join(long millis) to Specify Wait Time

The join(long millis) method allows the main thread to wait for a specific amount of time before it resumes execution.

If the specified time elapses before the thread finishes, the main thread continues without waiting for the child thread to finish.

Example 2: Using join(long millis)

class MyThreadWithDelay extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000); // Sleep for 1 second
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class JoinExample2 {
    public static void main(String[] args) {
        MyThreadWithDelay thread = new MyThreadWithDelay();
        thread.start();

        try {
            thread.join(2500); // Main thread waits for 2.5 seconds
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread proceeds after 2.5 seconds.");
    }
}

Output:

Thread: 1
Thread: 2
Main thread proceeds after 2.5 seconds.
Thread: 3
Thread: 4
Thread: 5

Explanation:

The join(2500) makes the main thread wait for 2.5 seconds. After this time, the main thread resumes execution, regardless of whether the child thread has finished.
In this case, the child thread continues running, but the main thread proceeds after the specified waiting time.

3. Using join(long millis, int nanos) for Higher Precision

The join(long millis, int nanos) method allows even finer control over the waiting time, providing additional precision using nanoseconds.

Example 3: Using join(long millis, int nanos)

class MyThreadWithNanoDelay extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000); // Sleep for 1 second
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class JoinExample3 {
    public static void main(String[] args) {
        MyThreadWithNanoDelay thread = new MyThreadWithNanoDelay();
        thread.start();

        try {
            thread.join(1000, 500000); // Main thread waits for 1.5 seconds (1 second and 500,000 nanoseconds)
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread proceeds after 1.5 seconds.");
    }
}

Output:

Thread: 1
Thread: 2
Main thread proceeds after 1.5 seconds.
Thread: 3
Thread: 4
Thread: 5

Explanation:

The join(1000, 500000) makes the main thread wait for approximately 1.5 seconds.
After the waiting time elapses, the main thread proceeds with execution, even if the child thread has not yet finished.

4. Joining Multiple Threads

You can also use the join() method to synchronize multiple threads. In this case, the main thread can wait for several threads to finish before proceeding.

Example 4: Joining Multiple Threads

class WorkerThread extends Thread {
    private String name;

    public WorkerThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println(name + ": " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class JoinExample4 {
    public static void main(String[] args) {
        WorkerThread thread1 = new WorkerThread("Thread 1");
        WorkerThread thread2 = new WorkerThread("Thread 2");
        WorkerThread thread3 = new WorkerThread("Thread 3");

        thread1.start();
        thread2.start();
        thread3.start();

        try {
            thread1.join(); // Wait for thread1 to finish
            thread2.join(); // Wait for thread2 to finish
            thread3.join(); // Wait for thread3 to finish
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread proceeds after all threads are finished.");
    }
}

Output:

Thread 1: 1
Thread 2: 1
Thread 3: 1
Thread 1: 2
Thread 2: 2
Thread 3: 2
Thread 1: 3
Thread 2: 3
Thread 3: 3
Main thread proceeds after all threads are finished.

Explanation:

The main thread waits for thread1, thread2, and thread3 to finish execution before proceeding.
By calling join() on each thread, the main thread ensures that all worker threads complete before it moves on.

5. Handling Interrupted Threads with join()

When using join(), a thread may be interrupted. It’s important to handle this scenario using the InterruptedException.

Example 5: Handling Interrupted Threads

class InterruptibleThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted!");
                return;
            }
        }
    }
}

public class JoinExample5 {
    public static void main(String[] args) {
        InterruptibleThread thread = new InterruptibleThread();
        thread.start();

        try {
            thread.join();
        } catch (InterruptedException e) {
            System.out.println("Main thread was interrupted!");
        }

        System.out.println("Main thread proceeds after thread completion or interruption.");
    }
}

Output:

Thread: 1
Thread: 2
Thread: 3
Main thread proceeds after thread completion or interruption.

Explanation:

If the thread gets interrupted while waiting, the InterruptedException is thrown.
In this case, the main thread catches the exception and handles the interruption gracefully.

6. Using join() in a Thread Pool

In real-world applications, we often use thread pools to manage multiple threads. Even within a thread pool, you can use join() to wait for specific threads to complete their tasks.

Example 6: Using join() with a Thread Pool

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ThreadPoolTask extends Thread {
    private String taskName;

    public ThreadPoolTask(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println(taskName + " is running.");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println(taskName + " was interrupted.");
        }
        System.out.println(taskName + " has finished.");
    }
}

public class JoinExample6 {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        ThreadPoolTask task1 = new ThreadPoolTask("Task 1");
        ThreadPoolTask task2 = new ThreadPoolTask("Task 2");
        ThreadPoolTask task3 = new ThreadPoolTask("Task 3");

        executor.execute(task1);
        executor.execute(task2);
        executor.execute(task3);

        executor.shutdown(); // Gracefully shut down the executor

        try {
            task1.join();
            task2.join();
            task3.join();
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread proceeds after all tasks are completed.");
    }
}

Output:

Task 1 is running.
Task 2 is running.
Task 3 is running.
Task 1 has finished.
Task 2 has finished.
Task 3 has finished.
Main thread proceeds after all tasks are completed.

Explanation:

In this example, the ExecutorService manages multiple threads.
After submitting the tasks to the thread pool, the join() method ensures that the main thread waits for the tasks to finish.

Conclusion

The join() method in Java is a powerful tool for controlling the execution order of threads.

It allows one thread to wait for the completion of another before proceeding, making it useful for scenarios where you need to synchronize threads or ensure that certain tasks complete before moving forward.

Key points:

Use join() to make one thread wait for another.
The join(long millis) and join(long millis, int nanos) methods allow you to specify how long to wait before continuing.
Handling InterruptedException is important when dealing with threads.
You can join multiple threads or use join() in thread pools to coordinate task completion.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Starting a Thread in Java tutorial with code examples

written by 75ypsaw71

In Java, threads are a fundamental part of concurrency and multi-threading. A thread is a lightweight process that allows a program to perform multiple tasks simultaneously.

Java provides several ways to create and start a thread, which is useful for making applications more responsive and capable of handling multiple operations concurrently.

There are two main ways to start a thread in Java:

Extending the Thread class.

Implementing the Runnable interface.
Both approaches allow you to run code concurrently, but they differ in how they are implemented and in their flexibility.

1. Starting a Thread by Extending the Thread Class

One way to create a thread in Java is by extending the Thread class and overriding its run() method. The run() method contains the code that will be executed by the thread.

Example 1: Extending the Thread Class

class MyThread extends Thread {
    @Override
    public void run() {
        // Code that will be executed by the thread
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ThreadExample1 {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // Start the thread
        
        // Main thread continues
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

Output (might vary due to thread scheduling):

Thread: 1
Main: 1
Thread: 2
Main: 2
Thread: 3
Main: 3
Thread: 4
Main: 4
Thread: 5
Main: 5

Explanation:

In this example, the MyThread class extends Thread and overrides the run() method.
The start() method is called to initiate the thread, which internally calls the run() method.
Both the main thread and the newly created thread run concurrently.

2. Starting a Thread by Implementing the Runnable Interface

Another way to start a thread is by implementing the Runnable interface. This approach is more flexible because your class can extend another class, unlike the previous method where you are restricted to extending Thread.

Example 2: Implementing the Runnable Interface

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Runnable: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ThreadExample2 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start(); // Start the thread
        
        // Main thread continues
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

Output (might vary):

Runnable: 1
Main: 1
Runnable: 2
Main: 2
Runnable: 3
Main: 3
Runnable: 4
Main: 4
Runnable: 5
Main: 5

Explanation:

The MyRunnable class implements the Runnable interface and provides the implementation of the run() method.
A Thread object is created and passed the runnable object as an argument to its constructor.
The start() method starts the thread, which invokes the run() method of MyRunnable.

3. Using Lambda Expressions with Threads

In Java 8 and later, you can use lambda expressions to create a thread in a more concise way when using the Runnable interface. This is particularly useful for reducing boilerplate code.

Example 3: Using Lambda Expression

public class ThreadExample3 {
    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Lambda: " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    System.out.println(e);
                }
            }
        };
        
        Thread thread = new Thread(task);
        thread.start(); // Start the thread
        
        // Main thread continues
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

Output:

Lambda: 1
Main: 1
Lambda: 2
Main: 2
Lambda: 3
Main: 3
Lambda: 4
Main: 4
Lambda: 5
Main: 5

Explanation:

In this example, the Runnable task is defined using a lambda expression, making the code more concise.
This approach is a modern and convenient way to create threads in Java, especially for short and simple tasks.

4. Using the Thread.join() Method

The join() method allows one thread to wait for the completion of another. This can be useful when you want the main thread to wait until another thread finishes its work.

Example 4: Using Thread.join()

class MyTask implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Task: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ThreadExample4 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTask());
        thread.start(); // Start the thread

        try {
            thread.join(); // Wait for the thread to finish
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        // Now the main thread will execute
        System.out.println("Main thread completed after task.");
    }
}

Output:

Task: 1
Task: 2
Task: 3
Task: 4
Task: 5
Main thread completed after task.

Explanation:

The thread.join() method makes the main thread wait for the thread to complete its execution before proceeding.
After the thread finishes, the main thread continues its execution.

5. Thread Priorities

Threads in Java can be assigned priorities. Java provides three priority levels:

Thread.MIN_PRIORITY (1)
Thread.NORM_PRIORITY (5) (default)
Thread.MAX_PRIORITY (10)
You can set a thread's priority using the setPriority() method, but keep in mind that thread priorities are only hints to the thread scheduler and may not be strictly followed by the JVM on all platforms.

Example 5: Setting Thread Priorities

class PriorityTask implements Runnable {
    private String name;

    public PriorityTask(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println(name + ": " + i);
        }
    }
}

public class ThreadExample5 {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new PriorityTask("Low Priority"));
        Thread thread2 = new Thread(new PriorityTask("High Priority"));

        thread1.setPriority(Thread.MIN_PRIORITY); // Priority 1
        thread2.setPriority(Thread.MAX_PRIORITY); // Priority 10

        thread1.start();
        thread2.start();
    }
}

Output:

High Priority: 1
High Priority: 2
High Priority: 3
Low Priority: 1
Low Priority: 2
Low Priority: 3

Explanation:

The thread with higher priority (thread2) is more likely to execute first, but thread scheduling is still dependent on the JVM and the operating system.
Setting priorities does not guarantee the order of execution.

6. Daemon Threads

A daemon thread is a low-priority thread that runs in the background to perform tasks like garbage collection. These threads do not prevent the JVM from exiting when all user threads (non-daemon threads) finish their execution.

Example 6: Daemon Thread

class DaemonTask implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("Daemon thread running...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ThreadExample6 {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(new DaemonTask());
        daemonThread.setDaemon(true); // Set this thread as daemon
        daemonThread.start();

        try {
            Thread.sleep(2000); // Main thread sleeps for 2 seconds
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread finished.");
    }
}

Output:

Daemon thread running...
Daemon thread running...
Daemon thread running...
Daemon thread running...
Main thread finished.

Explanation:

The daemon thread keeps running, but as soon as the main thread (the non-daemon thread) finishes, the program terminates, and the daemon thread is also stopped automatically.
Daemon threads are typically used for background tasks like garbage collection.

Conclusion

Java provides a variety of ways to create and manage threads, from extending the Thread class to implementing the Runnable interface.

You can control thread behavior using features like join(), priorities, and daemon threads. Understanding how to use threads effectively is crucial for building efficient, concurrent applications.

Key takeaways:

Extending Thread or implementing Runnable are two primary ways to start threads.
Use lambda expressions for concise code in modern Java.
Use join() to make one thread wait for another to finish.
Control thread execution order with priorities (though it's only a hint).
Use daemon threads for background tasks that should not prevent the JVM from exiting.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Using IdentityHashMap in Java tutorial

written by 75ypsaw71

In Java, a HashMap typically uses the .equals() method to compare keys, meaning that two keys are considered equal if their contents are the same.

However, if you want to compare keys by reference (i.e., you want two keys to be considered equal only if they refer to the same object in memory), you can use an IdentityHashMap.

An IdentityHashMap uses reference equality (==) instead of value equality (equals()). This means that it only considers two keys equal if they are the same instance (i.e., they point to the same memory location).

Key Characteristics of IdentityHashMap

Reference Equality: Compares keys using == instead of .equals().
Unusual Behavior for Autoboxing: When using primitive types like int with IdentityHashMap, autoboxing may lead to unexpected results since different instances of Integer objects are not guaranteed to be equal under ==.
Performance Considerations: Since IdentityHashMap does not rely on calculating hash codes from the key’s value, its performance characteristics may differ slightly from HashMap.

Importing IdentityHashMap

To use IdentityHashMap, you must import it from the java.util package.

import java.util.IdentityHashMap;

Example 1: Basic Usage of IdentityHashMap

Let’s begin with a simple example to show how IdentityHashMap compares keys using reference equality:

import java.util.IdentityHashMap;

public class IdentityHashMapExample {
    public static void main(String[] args) {
        IdentityHashMap<String, String> map = new IdentityHashMap<>();

        String key1 = new String("key");
        String key2 = new String("key"); // Another String object with the same content as key1

        map.put(key1, "value1");
        map.put(key2, "value2"); // This will be treated as a different key

        System.out.println("Size of map: " + map.size()); // Output: 2
        System.out.println("Value for key1: " + map.get(key1)); // Output: value1
        System.out.println("Value for key2: " + map.get(key2)); // Output: value2
    }
}

Explanation:

Here, key1 and key2 are different String objects with the same content (“key”), but IdentityHashMap treats them as different keys because it compares the references using ==.
Therefore, both entries are stored, and the map has a size of 2.

Example 2: IdentityHashMap with Integer Autoboxing

Here’s an example demonstrating the behavior of IdentityHashMap when used with autoboxed Integer objects:

import java.util.IdentityHashMap;

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

        Integer key1 = 1000;
        Integer key2 = 1000; // Autoboxing: different instances with the same value
        Integer key3 = 10;
        Integer key4 = 10;   // Autoboxing: cached Integer instances for small numbers

        map.put(key1, "value1");
        map.put(key2, "value2"); // Different instance, so this will be treated as a different key
        map.put(key3, "value3");
        map.put(key4, "value4"); // Same instance, will overwrite the previous value

        System.out.println("Size of map: " + map.size()); // Output: 3
        System.out.println("Value for key1: " + map.get(key1)); // Output: value1
        System.out.println("Value for key2: " + map.get(key2)); // Output: value2
        System.out.println("Value for key3: " + map.get(key3)); // Output: value4
        System.out.println("Value for key4: " + map.get(key4)); // Output: value4
    }
}

Explanation:

When Integer objects are created using autoboxing, Java caches small numbers (between -128 and 127), so key3 and key4 refer to the same object.
For larger numbers, such as 1000, new instances are created for each autoboxing operation, so key1 and key2 are different objects even though they have the same value. This causes IdentityHashMap to store them as separate keys.

Example 3: Using Custom Objects as Keys

Let’s see how IdentityHashMap behaves when using custom objects as keys:

import java.util.IdentityHashMap;

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

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

        Person p1 = new Person("Alice");
        Person p2 = new Person("Alice"); // Different instance with the same name

        map.put(p1, "Developer");
        map.put(p2, "Designer"); // Different instance, treated as a separate key

        System.out.println("Size of map: " + map.size()); // Output: 2
        System.out.println("p1's profession: " + map.get(p1)); // Output: Developer
        System.out.println("p2's profession: " + map.get(p2)); // Output: Designer
    }
}

Explanation:

Even though p1 and p2 have the same value for the name attribute, they are treated as separate keys because IdentityHashMap compares their references using ==.
Hence, the map stores two separate entries, and both objects (p1 and p2) are treated as distinct keys.

Example 4: Comparing with HashMap

Let’s contrast the behavior of IdentityHashMap with HashMap:

import java.util.HashMap;
import java.util.IdentityHashMap;

public class CompareMaps {
    public static void main(String[] args) {
        // Using HashMap (compares keys with .equals())
        HashMap<String, String> hashMap = new HashMap<>();
        String key1 = new String("key");
        String key2 = new String("key");
        
        hashMap.put(key1, "value1");
        hashMap.put(key2, "value2"); // Will overwrite the value of key1 because .equals() returns true

        System.out.println("HashMap size: " + hashMap.size()); // Output: 1
        System.out.println("HashMap value for key1: " + hashMap.get(key1)); // Output: value2

        // Using IdentityHashMap (compares keys with ==)
        IdentityHashMap<String, String> identityHashMap = new IdentityHashMap<>();
        identityHashMap.put(key1, "value1");
        identityHashMap.put(key2, "value2"); // Will not overwrite because key1 and key2 are different objects

        System.out.println("IdentityHashMap size: " + identityHashMap.size()); // Output: 2
        System.out.println("IdentityHashMap value for key1: " + identityHashMap.get(key1)); // Output: value1
        System.out.println("IdentityHashMap value for key2: " + identityHashMap.get(key2)); // Output: value2
    }
}

Explanation:

In the HashMap example, since key1 and key2 are considered equal (.equals() returns true), the second put operation overwrites the value.
In the IdentityHashMap example, the two keys are not equal (key1 == key2 is false), so both entries are stored separately.

When to Use IdentityHashMap

Object Reference Uniqueness: If you need to distinguish objects based on their references rather than their content, IdentityHashMap is useful.
Performance for Caching: In certain caching scenarios where keys must be compared by reference, IdentityHashMap can be more efficient.

Conclusion

IdentityHashMap is a specialized type of map that compares keys by reference (==). It differs from the typical HashMap, which compares keys by value (.equals()). While IdentityHashMap is not commonly used, it can be useful in scenarios where reference equality is required. Understanding its behavior with different data types, such as autoboxed primitives and custom objects, helps to avoid unintended consequences.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Java SortedSet Interface Tutorial

written by 75ypsaw71

The SortedSet interface in Java is part of the java.util package and is a specialized version of the Set interface. It ensures that the elements in the set are sorted in their natural order or according to a custom comparator provided at the time of set creation.

Unlike Set, which only guarantees uniqueness, SortedSet guarantees both uniqueness and a sorted order of elements.

In this tutorial, we'll cover:

Overview of the SortedSet interface.
Common methods in SortedSet.
Implementations of SortedSet (TreeSet).
Code examples demonstrating various SortedSet operations.

1. SortedSet Interface Overview

A SortedSet maintains its elements in ascending order by default. If you insert elements into a SortedSet, they will automatically be arranged according to their natural ordering (for example, numbers are sorted numerically, and strings are sorted lexicographically).

Common Implementations of SortedSet
TreeSet: The most common implementation of SortedSet. It uses a balanced tree structure (Red-Black Tree) to store elements in a sorted manner.

2. Common Methods in SortedSet

Apart from the usual methods provided by the Set interface, the SortedSet interface provides some additional methods related to sorting:

Comparator<? super E> comparator(): Returns the comparator used to order the elements in the set, or null if natural ordering is used.
E first(): Returns the first (lowest) element currently in the set.
E last(): Returns the last (highest) element currently in the set.
SortedSet headSet(E toElement): Returns a view of the portion of this set whose elements are strictly less than toElement.
SortedSet tailSet(E fromElement): Returns a view of the portion of this set whose elements are greater than or equal to fromElement.
SortedSet subSet(E fromElement, E toElement): Returns a view of the portion of this set whose elements range from fromElement (inclusive) to toElement (exclusive).

3. TreeSet Implementation of SortedSet

The TreeSet class is the most common implementation of SortedSet. It stores elements in sorted order using a self-balancing tree (Red-Black Tree).

Example 1: Basic TreeSet Operations

import java.util.SortedSet;
import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        // Creating a TreeSet (SortedSet) of integers
        SortedSet treeSet = new TreeSet<>();

        // Adding elements to the TreeSet
        treeSet.add(10);
        treeSet.add(5);
        treeSet.add(20);
        treeSet.add(15);

        // Displaying the elements (sorted order)
        System.out.println("TreeSet: " + treeSet);  // [5, 10, 15, 20]

        // Accessing the first and last elements
        System.out.println("First element: " + treeSet.first());  // 5
        System.out.println("Last element: " + treeSet.last());    // 20

        // Getting a subset of elements (between 5 and 15)
        SortedSet subSet = treeSet.subSet(5, 15);
        System.out.println("SubSet (5 to 15): " + subSet);  // [5, 10]
    }
}

Explanation:

TreeSet: Maintains the elements in sorted order.
first() and last(): Retrieve the smallest and largest elements, respectively.
subSet(): Returns a view of the portion of the set between the specified range of elements.

4. Working with headSet and tailSet

Example 2: Using headSet and tailSet

import java.util.SortedSet;
import java.util.TreeSet;

public class HeadTailSetExample {
    public static void main(String[] args) {
        // Creating a TreeSet of string elements
        SortedSet treeSet = new TreeSet<>();

        // Adding elements to the TreeSet
        treeSet.add("Apple");
        treeSet.add("Banana");
        treeSet.add("Orange");
        treeSet.add("Grapes");
        treeSet.add("Mango");

        // Getting a headSet (elements less than Mango)
        SortedSet headSet = treeSet.headSet("Mango");
        System.out.println("HeadSet (less than Mango): " + headSet);  // [Apple, Banana, Grapes]

        // Getting a tailSet (elements greater than or equal to Mango)
        SortedSet tailSet = treeSet.tailSet("Mango");
        System.out.println("TailSet (greater than or equal to Mango): " + tailSet);  // [Mango, Orange]
    }
}

Explanation:

headSet(toElement): Returns a view of the portion of the set that contains elements less than the specified element.
tailSet(fromElement): Returns a view of the portion of the set that contains elements greater than or equal to the specified element.

5. Custom Comparator in TreeSet

By default, TreeSet uses the natural ordering of elements. However, you can provide a custom comparator when creating the TreeSet to define a different sorting order.

Example 3: TreeSet with Custom Comparator (Reverse Order)

import java.util.Comparator;
import java.util.SortedSet;
import java.util.TreeSet;

public class CustomComparatorExample {
    public static void main(String[] args) {
        // Creating a TreeSet with a custom comparator (reverse order)
        SortedSet treeSet = new TreeSet<>(Comparator.reverseOrder());

        // Adding elements
        treeSet.add(10);
        treeSet.add(5);
        treeSet.add(20);
        treeSet.add(15);

        // Displaying the elements (sorted in reverse order)
        System.out.println("TreeSet with custom comparator: " + treeSet);  // [20, 15, 10, 5]
    }
}

Explanation:

Comparator.reverseOrder(): A built-in comparator that sorts elements in descending (reverse) order.
The elements in the TreeSet are now sorted from largest to smallest.

6. Navigating a SortedSet

SortedSet provides methods like first(), last(), headSet(), and tailSet() to navigate through the set. Let’s explore more navigation techniques.

Example 4: Using Navigation Methods in SortedSet

import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSetNavigation {
    public static void main(String[] args) {
        SortedSet treeSet = new TreeSet<>();
        treeSet.add("Apple");
        treeSet.add("Banana");
        treeSet.add("Orange");
        treeSet.add("Mango");
        treeSet.add("Grapes");

        // Accessing the first and last elements
        System.out.println("First element: " + treeSet.first());  // Apple
        System.out.println("Last element: " + treeSet.last());    // Orange

        // Accessing a subset (between Apple and Orange)
        SortedSet subSet = treeSet.subSet("Apple", "Orange");
        System.out.println("SubSet (Apple to Orange): " + subSet);  // [Apple, Banana, Grapes, Mango]

        // Accessing headSet (less than Mango)
        SortedSet headSet = treeSet.headSet("Mango");
        System.out.println("HeadSet (less than Mango): " + headSet);  // [Apple, Banana, Grapes]
    }
}

Explanation:

subSet() returns a view of the set between two elements.
headSet() and tailSet() return parts of the set based on the specified elements.

7. Using Custom Objects in a TreeSet

You can use custom objects in a TreeSet. However, the custom object class must either implement the Comparable interface or you must provide a Comparator to define the ordering.

Example 5: Using Custom Objects in TreeSet

import java.util.SortedSet;
import java.util.TreeSet;

class Person implements Comparable {
    String name;
    int age;

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

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);  // Sorting by age
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class TreeSetCustomObjectExample {
    public static void main(String[] args) {
        // Creating a TreeSet where elements are Person objects
        SortedSet personSet = new TreeSet<>();

        personSet.add(new Person("Alice", 30));
        personSet.add(new Person("Bob", 25));
        personSet.add(new Person("Charlie", 35));

        // Displaying the TreeSet (sorted by age)
        for (Person person : personSet) {
            System.out.println(person);
        }
    }
}

Explanation:

The Person class implements the Comparable interface and defines the compareTo() method to sort the objects by age.
The TreeSet stores Person objects and automatically sorts them based on age.

8. Key Considerations for SortedSet

Sorting: Elements in a SortedSet are automatically sorted. By default, it uses natural ordering (as defined by Comparable), but you can provide a custom Comparator.
Uniqueness: Like all sets, a SortedSet ensures that duplicate elements are not allowed.
Navigability: SortedSet allows efficient navigation through the set using methods like first(), last(), subSet(), headSet(), and tailSet().

Conclusion

In this tutorial, we explored the SortedSet interface in Java, focusing on its common implementation TreeSet. We covered:

Basic operations like add(), remove(), first(), and last().
Navigation methods like headSet(), tailSet(), and subSet().
Creating TreeSet objects with custom comparators and using custom objects in the set.

The SortedSet interface is a powerful tool when you need to maintain a sorted collection of elements, and it offers efficient operations with logarithmic time complexity for most operations.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Java SortedMap Interface Tutorial

written by 75ypsaw71

The SortedMap interface in Java is part of the java.util package and is a specialized version of the Map interface. As the name suggests, the SortedMap interface ensures that the entries (key-value pairs) are maintained in a sorted order based on the natural ordering of the keys or by a custom comparator provided during map construction.

In this tutorial, we will cover:

Overview of the SortedMap interface.
Common methods in SortedMap.
Implementations of SortedMap (TreeMap).
Code examples demonstrating common SortedMap operations.

1. SortedMap Interface Overview

A SortedMap sorts its keys either by their natural ordering (which requires the keys to implement Comparable) or by a custom Comparator.
The keys must be unique, and the sorting is done in ascending order by default.

Common Implementations of SortedMap

TreeMap: This is the most common implementation of SortedMap. It stores key-value pairs in a tree structure (Red-Black Tree), ensuring that the keys are sorted.

2. Common Methods in SortedMap

Apart from the usual Map interface methods, SortedMap provides some additional methods related to the sorting of keys:

Comparator<? super K> comparator(): Returns the comparator used to order the keys, or null if natural ordering is used.
K firstKey(): Returns the first (lowest) key in the map.
K lastKey(): Returns the last (highest) key in the map.
SortedMap<K, V> headMap(K toKey): Returns a view of the portion of the map whose keys are strictly less than toKey.
SortedMap<K, V> tailMap(K fromKey): Returns a view of the portion of the map whose keys are greater than or equal to fromKey.
SortedMap<K, V> subMap(K fromKey, K toKey): Returns a view of the portion of the map whose keys range from fromKey (inclusive) to toKey (exclusive).

3. TreeMap Implementation of SortedMap

The TreeMap class is the most commonly used implementation of the SortedMap interface. It maintains the entries in a sorted order based on the natural ordering of the keys or a custom comparator.

Example 1: Basic TreeMap Operations

import java.util.SortedMap;
import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        // Creating a TreeMap (SortedMap) of strings to integers
        SortedMap<String, Integer> treeMap = new TreeMap<>();

        // Adding key-value pairs using put()
        treeMap.put("Apple", 5);
        treeMap.put("Banana", 2);
        treeMap.put("Orange", 7);
        treeMap.put("Mango", 3);

        // Displaying the TreeMap (sorted by key)
        System.out.println("SortedMap: " + treeMap);  // {Apple=5, Banana=2, Mango=3, Orange=7}

        // Accessing the first and last keys
        System.out.println("First key: " + treeMap.firstKey());  // Apple
        System.out.println("Last key: " + treeMap.lastKey());    // Orange

        // Getting a subMap (from Banana to Mango)
        SortedMap<String, Integer> subMap = treeMap.subMap("Banana", "Orange");
        System.out.println("SubMap (Banana to Orange): " + subMap);  // {Banana=2, Mango=3}
    }
}

Explanation:

TreeMap: Maintains a sorted order of keys.
firstKey() and lastKey(): Return the lowest and highest keys, respectively.
subMap(): Returns a portion of the map between two specified keys (fromKey inclusive and toKey exclusive).

Example 2: Working with HeadMap and TailMap

import java.util.SortedMap;
import java.util.TreeMap;

public class HeadTailMapExample {
    public static void main(String[] args) {
        // Creating a TreeMap of string keys and integer values
        SortedMap<String, Integer> treeMap = new TreeMap<>();

        treeMap.put("Apple", 5);
        treeMap.put("Banana", 2);
        treeMap.put("Mango", 3);
        treeMap.put("Orange", 7);
        treeMap.put("Grapes", 8);

        // Getting a headMap (keys less than Mango)
        SortedMap<String, Integer> headMap = treeMap.headMap("Mango");
        System.out.println("HeadMap (keys less than Mango): " + headMap);  // {Apple=5, Banana=2}

        // Getting a tailMap (keys greater than or equal to Mango)
        SortedMap<String, Integer> tailMap = treeMap.tailMap("Mango");
        System.out.println("TailMap (keys greater than or equal to Mango): " + tailMap);  // {Mango=3, Orange=7}
    }
}

Explanation:

headMap(toKey): Returns a view of the portion of the map with keys less than toKey.
tailMap(fromKey): Returns a view of the portion of the map with keys greater than or equal to fromKey.

4. Custom Comparator in TreeMap

By default, TreeMap uses the natural ordering of the keys (e.g., alphabetical for String). You can provide a custom comparator when creating a TreeMap to change the ordering.

Example 3: TreeMap with Custom Comparator (Reverse Order)

import java.util.Comparator;
import java.util.SortedMap;
import java.util.TreeMap;

public class CustomComparatorExample {
    public static void main(String[] args) {
        // Creating a TreeMap with a custom comparator (reverse order)
        SortedMap<String, Integer> treeMap = new TreeMap<>(Comparator.reverseOrder());

        // Adding key-value pairs
        treeMap.put("Apple", 5);
        treeMap.put("Banana", 2);
        treeMap.put("Orange", 7);
        treeMap.put("Mango", 3);

        // Displaying the TreeMap (sorted by keys in reverse order)
        System.out.println("SortedMap with custom comparator: " + treeMap);  // {Orange=7, Mango=3, Banana=2, Apple=5}
    }
}

Explanation:

Comparator.reverseOrder(): A built-in comparator that sorts keys in reverse (descending) order.
The keys in the TreeMap are now sorted from highest to lowest.

5. Navigating a SortedMap

SortedMap provides methods like firstKey(), lastKey(), headMap(), and tailMap() to allow navigation through the map. Let's explore more navigation techniques.

Example 4: Using Navigation Methods in SortedMap

import java.util.SortedMap;
import java.util.TreeMap;

public class SortedMapNavigation {
    public static void main(String[] args) {
        SortedMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Apple", 5);
        treeMap.put("Banana", 2);
        treeMap.put("Orange", 7);
        treeMap.put("Mango", 3);
        treeMap.put("Grapes", 8);

        // Accessing the first and last keys
        System.out.println("First key: " + treeMap.firstKey());  // Apple
        System.out.println("Last key: " + treeMap.lastKey());    // Orange

        // Accessing a subMap (between Apple and Orange)
        SortedMap<String, Integer> subMap = treeMap.subMap("Apple", "Orange");
        System.out.println("SubMap (Apple to Orange): " + subMap);  // {Apple=5, Banana=2, Grapes=8, Mango=3}

        // Accessing headMap (keys less than Mango)
        SortedMap<String, Integer> headMap = treeMap.headMap("Mango");
        System.out.println("HeadMap (keys less than Mango): " + headMap);  // {Apple=5, Banana=2, Grapes=8}
    }
}

Explanation:

subMap() gives you a range view of the map between two specified keys.
headMap() and tailMap() give you parts of the map based on the specified keys.

6. Example of TreeMap with Custom Object Keys

You can use custom objects as keys in a TreeMap. However, the custom object must either implement the Comparable interface or you must provide a Comparator to define the sorting order.

Example 5: Using Custom Object as Keys in TreeMap

import java.util.SortedMap;
import java.util.TreeMap;

class Person implements Comparable {
    String name;
    int age;

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

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);  // Sorting by age
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class TreeMapCustomObjectExample {
    public static void main(String[] args) {
        // Creating a TreeMap where keys are Person objects
        SortedMap<Person, String> personMap = new TreeMap<>();

        personMap.put(new Person("Alice", 30), "HR");
        personMap.put(new Person("Bob", 25), "Finance");
        personMap.put(new Person("Charlie", 35), "IT");

        // Displaying the TreeMap (sorted by age, which is defined in compareTo)
        for (Map.Entry<Person, String> entry : personMap.entrySet()) {
            System.out.println(entry.getKey() + " works in " + entry.getValue());
        }
    }
}

Explanation:

The Person class implements Comparable, and the compareTo() method sorts Person objects by age.
The TreeMap stores Person objects as keys and sorts them based on their age.

7. Key Considerations for SortedMap

Sorted by keys: SortedMap implementations (like TreeMap) always maintain the order of the keys.
Performance: In a TreeMap, the time complexity for basic operations like put(), get(), remove(), and containsKey() is O(log n) because the keys are stored in a tree structure.
Custom comparators: You can easily change the sorting order of a SortedMap by providing a custom comparator.

Conclusion

In this tutorial, we explored the SortedMap interface in Java, focusing on its common implementation TreeMap. We discussed key operations such as:

Basic operations (put(), get(), remove()).
Navigating the map using headMap(), tailMap(), and subMap().
Custom sorting with comparators and custom objects as keys.

The SortedMap interface is a powerful tool when you need to maintain a sorted collection of key-value pairs, making it highly useful for scenarios like scheduling, range queries, and more.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Java Map Interface Tutorial

written by 75ypsaw71

The Map interface in Java is part of the java.util package and represents a collection of key-value pairs.

Unlike the Collection interface, which focuses on individual elements, the Map interface associates each key with a specific value. Keys in a Map must be unique, but values can be duplicated.

This tutorial covers:

Overview of the Map interface.
Common implementations (HashMap, LinkedHashMap, TreeMap).
Code examples demonstrating various Map operations.

1. Map Interface Overview

Key Methods in the Map Interface

put(K key, V value): Associates the specified value with the specified key. If the key already exists, its value is updated.
get(Object key): Returns the value associated with the specified key or null if the key doesn't exist.
remove(Object key): Removes the key-value pair for the specified key.
containsKey(Object key): Returns true if the map contains the specified key.
containsValue(Object value): Returns true if the map contains the specified value.
keySet(): Returns a Set of all keys in the map.
values(): Returns a Collection of all values in the map.
entrySet(): Returns a Set of all key-value pairs (as Map.Entry objects) in the map.

2. HashMap Implementation Example

A HashMap is the most commonly used implementation of the Map interface. It stores key-value pairs in an unsorted and unordered manner. Keys are unique, and the map allows null values and one null key.

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        // Creating a HashMap
        Map<String, Integer> ageMap = new HashMap<>();

        // Adding key-value pairs using put()
        ageMap.put("Alice", 30);
        ageMap.put("Bob", 25);
        ageMap.put("Charlie", 35);

        // Accessing values using get()
        System.out.println("Alice's age: " + ageMap.get("Alice"));  // 30
        System.out.println("Bob's age: " + ageMap.get("Bob"));      // 25

        // Checking if a key or value exists
        System.out.println("Contains key 'Charlie'? " + ageMap.containsKey("Charlie"));  // true
        System.out.println("Contains value 30? " + ageMap.containsValue(30));            // true

        // Removing an entry
        ageMap.remove("Alice");
        System.out.println("Map after removing Alice: " + ageMap);

        // Iterating over keys and values
        System.out.println("All keys: " + ageMap.keySet());
        System.out.println("All values: " + ageMap.values());

        // Iterating using entrySet()
        for (Map.Entry<String, Integer> entry : ageMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Explanation:

put(): Adds key-value pairs to the map. If the key exists, the value is replaced.
get(): Retrieves the value associated with a specific key.
containsKey() and containsValue(): Check if a key or value exists in the map.
remove(): Removes a key-value pair based on the key.
keySet() and values(): Retrieve all keys and values, respectively.
entrySet(): Returns a set of Map.Entry objects, allowing iteration over key-value pairs.

3. LinkedHashMap Implementation Example

A LinkedHashMap maintains the insertion order of its key-value pairs. This means that when you iterate over the map, the keys and values appear in the order in which they were inserted.

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // Creating a LinkedHashMap
        Map<String, Integer> orderedMap = new LinkedHashMap<>();

        // Adding key-value pairs
        orderedMap.put("Apple", 100);
        orderedMap.put("Banana", 50);
        orderedMap.put("Cherry", 75);

        // Iterating over the map (will maintain insertion order)
        System.out.println("Iterating over LinkedHashMap:");
        for (Map.Entry<String, Integer> entry : orderedMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // Accessing values in insertion order
        System.out.println("First item inserted: " + orderedMap.entrySet().iterator().next());
    }
}

Explanation:

A LinkedHashMap maintains the order in which key-value pairs are inserted, unlike HashMap, which has no specific order.
You can iterate through the map and expect the elements to appear in the order of insertion.

4. TreeMap Implementation Example

A TreeMap stores its key-value pairs in sorted order according to the natural ordering of the keys (or a custom Comparator if provided).

import java.util.Map;
import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        // Creating a TreeMap
        Map<String, Integer> sortedMap = new TreeMap<>();

        // Adding key-value pairs (keys will be sorted in natural order)
        sortedMap.put("Banana", 50);
        sortedMap.put("Apple", 100);
        sortedMap.put("Cherry", 75);

        // Iterating over the map (keys will be sorted)
        System.out.println("Iterating over TreeMap:");
        for (Map.Entry<String, Integer> entry : sortedMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Explanation:

A TreeMap sorts its keys in natural order (lexicographically for strings).
When iterating through a TreeMap, the entries are returned in sorted order based on the keys.

5. Iterating Over a Map

Java offers several ways to iterate over a Map. Let’s look at a few common approaches.

Example: Iterating Over Key-Value Pairs Using entrySet()

import java.util.HashMap;
import java.util.Map;

public class MapIterationExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);

        // Iterating using entrySet()
        System.out.println("Iterating using entrySet():");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // Iterating using keySet() and get()
        System.out.println("\nIterating using keySet() and get():");
        for (String key : map.keySet()) {
            System.out.println("Key: " + key + ", Value: " + map.get(key));
        }

        // Iterating using forEach (Java 8+)
        System.out.println("\nIterating using forEach() (Java 8+):");
        map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
    }
}

Explanation:

entrySet(): Returns a set of key-value pairs, allowing you to iterate over both the keys and values simultaneously.
keySet(): Returns a set of keys, and you can retrieve corresponding values using the get() method.
forEach(): Introduced in Java 8, allows for concise iteration over the map.

6. Common Operations on a Map

Example: Basic Operations

import java.util.HashMap;
import java.util.Map;

public class MapOperationsExample {
    public static void main(String[] args) {
        Map<String, String> capitals = new HashMap<>();

        // Adding key-value pairs using put()
        capitals.put("France", "Paris");
        capitals.put("Germany", "Berlin");
        capitals.put("USA", "Washington D.C.");
        capitals.put("Japan", "Tokyo");

        // Accessing values using get()
        System.out.println("Capital of Germany: " + capitals.get("Germany"));  // Berlin

        // Checking if a key or value exists
        System.out.println("Contains key 'USA'? " + capitals.containsKey("USA"));  // true
        System.out.println("Contains value 'Paris'? " + capitals.containsValue("Paris"));  // true

        // Removing a key-value pair
        capitals.remove("Japan");
        System.out.println("Map after removing Japan: " + capitals);

        // Replacing a value
        capitals.replace("France", "Marseille");
        System.out.println("Map after replacing France's capital: " + capitals);
    }
}

Explanation:

put(): Adds key-value pairs or updates the value if the key already exists.
get(): Retrieves the value associated with the specified key.
remove(): Removes a key-value pair.
replace(): Replaces the value for a specific key.

7. Map of Custom Objects

You can use custom objects as keys or values in a Map, provided the key class implements hashCode() and equals() properly.

Example: Using Custom Objects as Keys

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

class Employee {
    String id;
    String name;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee)) return false;
        Employee employee = (Employee) o;
        return Objects.equals(id, employee.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    @Override
    public String toString() {
        return name;
    }
}

public class CustomObjectMapExample {
    public static void main(String[] args) {
        Map<Employee, String> employeeDepartmentMap = new HashMap<>();

        // Creating Employee objects
        Employee emp1 = new Employee("E001", "John Doe");
        Employee emp2 = new Employee("E002", "Jane Smith");

        // Adding employees to the map
        employeeDepartmentMap.put(emp1, "HR");
        employeeDepartmentMap.put(emp2, "Finance");

        // Accessing map entries
        System.out.println("John's Department: " + employeeDepartmentMap.get(emp1));  // HR
        System.out.println("Jane's Department: " + employeeDepartmentMap.get(emp2));  // Finance
    }
}

Explanation:

Custom objects can be used as keys in a Map, but you must override equals() and hashCode() to ensure proper functioning.
In this example, Employee objects are used as keys, and their departments are stored as values.

Conclusion

The Map interface in Java is a powerful tool for managing key-value pairs, and it provides several implementations suited for different use cases:

HashMap: For fast, unsorted, and unordered mappings.
LinkedHashMap: For mappings that maintain the order of insertion.
TreeMap: For sorted mappings.
Custom Objects as Keys: Ensure that custom classes properly implement equals() and hashCode().

Using these implementations effectively allows you to manage collections of data in a way that suits the requirements of your project.

0 comment
0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts