Category:

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:

What is Thread Interruption in Java?
Using interrupt() to Signal a Thread
Checking the Interrupt Status
Handling InterruptedException
Best Practices for Handling Thread Interruption
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.

October 21, 2024 0 comment

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.

Table of Contents

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.

October 15, 2024 0 comment

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.

Table of Contents

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.

October 15, 2024 0 comment

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.

Table of Contents

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.

October 15, 2024 0 comment

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).

Table of Contents

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.

October 15, 2024 0 comment

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.

Table of Contents

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.

October 11, 2024 0 comment

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.

Table of Contents

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.

October 11, 2024 0 comment

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.

Table of Contents

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.

October 11, 2024 0 comment

Misc

Java Queue Interface Tutorial

written by 75ypsaw71

The Queue interface in Java is a part of the java.util package and extends the Collection interface.

It represents a collection designed for holding elements prior to processing, typically in a FIFO (First-In-First-Out) manner.

The Queue interface provides methods to add, remove, and inspect elements, offering variations of these operations to handle both normal and exceptional conditions.

Table of Contents

In this tutorial, we'll cover:

Basic operations of the Queue interface.
Implementations of Queue (such as LinkedList and PriorityQueue).
Code examples demonstrating common queue operations.
Queue Interface Overview

Common Methods in the Queue Interface

add(E e): Inserts the specified element into the queue. Throws an exception if the operation fails (e.g., capacity limits).
offer(E e): Inserts the specified element into the queue. Returns false if the operation fails instead of throwing an exception.
remove(): Retrieves and removes the head of the queue. Throws an exception if the queue is empty.
poll(): Retrieves and removes the head of the queue. Returns null if the queue is empty.
element(): Retrieves, but does not remove, the head of the queue. Throws an exception if the queue is empty.
peek(): Retrieves, but does not remove, the head of the queue. Returns null if the queue is empty.

1. Using a Queue with LinkedList

The LinkedList class implements the Queue interface, allowing you to use it as a queue. Let's look at some examples.

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        // Creating a Queue using LinkedList
        Queue queue = new LinkedList<>();

        // Adding elements using add() and offer()
        queue.add("Alice");
        queue.offer("Bob");
        queue.offer("Charlie");

        System.out.println("Queue: " + queue);  // [Alice, Bob, Charlie]

        // Accessing the head element using element() and peek()
        System.out.println("Head (element): " + queue.element());  // Alice
        System.out.println("Head (peek): " + queue.peek());        // Alice

        // Removing elements using remove() and poll()
        System.out.println("Removed (remove): " + queue.remove()); // Alice
        System.out.println("Queue after remove: " + queue);        // [Bob, Charlie]

        System.out.println("Removed (poll): " + queue.poll());     // Bob
        System.out.println("Queue after poll: " + queue);          // [Charlie]

        // Poll on empty queue returns null
        queue.poll();  // Charlie is removed
        System.out.println("Empty queue poll: " + queue.poll());   // null

        // Element on empty queue throws exception
        // System.out.println(queue.element());  // Throws NoSuchElementException
    }
}

Explanation:

add() and offer() both insert elements into the queue. The difference is that add() throws an exception if the queue is full, whereas offer() returns false.
remove() and poll() both remove the head element. The difference is that remove() throws an exception if the queue is empty, while poll() returns null.
element() and peek() both return the head element without removing it. element() throws an exception if the queue is empty, while peek() returns null.

2. Using a Queue with PriorityQueue

The PriorityQueue class is another implementation of the Queue interface that orders elements according to their natural ordering or by a Comparator provided at queue construction time. Let's explore how it works.

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        // Creating a PriorityQueue of integers
        Queue priorityQueue = new PriorityQueue<>();

        // Adding elements using add() and offer()
        priorityQueue.add(15);
        priorityQueue.offer(10);
        priorityQueue.offer(30);
        priorityQueue.offer(25);

        System.out.println("PriorityQueue: " + priorityQueue);  // [10, 15, 30, 25]

        // Accessing the head element using element() and peek()
        System.out.println("Head (element): " + priorityQueue.element());  // 10
        System.out.println("Head (peek): " + priorityQueue.peek());        // 10

        // Removing elements using remove() and poll()
        System.out.println("Removed (remove): " + priorityQueue.remove()); // 10
        System.out.println("PriorityQueue after remove: " + priorityQueue); // [15, 25, 30]

        System.out.println("Removed (poll): " + priorityQueue.poll());     // 15
        System.out.println("PriorityQueue after poll: " + priorityQueue);  // [25, 30]
    }
}

Explanation:

The PriorityQueue orders its elements based on their natural ordering (Comparable) or a custom Comparator.
In this case, smaller numbers have higher priority, so the element 10 is at the head of the queue.
The queue is not necessarily sorted when printed, but the smallest element is always at the head of the queue.

3. Example of Using a PriorityQueue with Custom Comparator

You can also provide a custom comparator to change the order in which elements are processed in a PriorityQueue.

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class CustomPriorityQueueExample {
    public static void main(String[] args) {
        // Creating a PriorityQueue with a custom comparator for reverse order
        Queue priorityQueue = new PriorityQueue<>(Comparator.reverseOrder());

        // Adding elements
        priorityQueue.offer(15);
        priorityQueue.offer(10);
        priorityQueue.offer(30);
        priorityQueue.offer(25);

        System.out.println("PriorityQueue: " + priorityQueue);  // [30, 25, 15, 10]

        // Accessing the head element (which now has the largest value due to reverse order)
        System.out.println("Head (peek): " + priorityQueue.peek());  // 30

        // Removing elements
        System.out.println("Removed: " + priorityQueue.poll());  // 30
        System.out.println("PriorityQueue after poll: " + priorityQueue);  // [25, 10, 15]
    }
}

Explanation:

We pass a custom comparator (Comparator.reverseOrder()) to the PriorityQueue constructor to create a max-heap. Now, the largest element is always at the head of the queue.

4. Blocking Queues (e.g., LinkedBlockingQueue)

Java also provides blocking queues, which are useful in multithreaded environments. A BlockingQueue blocks a thread trying to add() elements if the queue is full, and it blocks a thread trying to remove() elements if the queue is empty.

Here’s an example of using LinkedBlockingQueue:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        // Creating a LinkedBlockingQueue
        BlockingQueue blockingQueue = new LinkedBlockingQueue<>(3);

        // Adding elements
        blockingQueue.put("Alice");
        blockingQueue.put("Bob");
        blockingQueue.put("Charlie");

        System.out.println("BlockingQueue: " + blockingQueue);  // [Alice, Bob, Charlie]

        // Adding one more element will block until there's space
        new Thread(() -> {
            try {
                blockingQueue.put("David");
                System.out.println("David added to the queue.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // Simulate processing and removing an element
        Thread.sleep(1000);
        System.out.println("Removed: " + blockingQueue.take());  // Alice
        System.out.println("BlockingQueue after take: " + blockingQueue);  // [Bob, Charlie]
    }
}

Explanation:

LinkedBlockingQueue is an implementation of a blocking queue with a fixed capacity.
The put() method blocks when the queue is full, and the take() method blocks when the queue is empty.

5. Deque Interface (Double-Ended Queue)

The Deque interface extends Queue and allows you to insert and remove elements from both ends of the queue. A common implementation is ArrayDeque.

import java.util.ArrayDeque;
import java.util.Deque;

public class DequeExample {
    public static void main(String[] args) {
        // Creating a Deque using ArrayDeque
        Deque deque = new ArrayDeque<>();

        // Adding elements at both ends
        deque.addFirst("Alice");
        deque.addLast("Bob");
        deque.offerFirst("Charlie");
        deque.offerLast("David");

        System.out.println("Deque: " + deque);  // [Charlie, Alice, Bob, David]

        // Accessing elements from both ends
        System.out.println("First element: " + deque.getFirst());  // Charlie
        System.out.println("Last element: " + deque.getLast());    // David

        // Removing elements from both ends
        System.out.println("Removed first: " + deque.removeFirst()); // Charlie
        System.out.println("Removed last: " + deque.removeLast());   // David

        System.out.println("Deque after removals: " + deque);  // [Alice, Bob]
    }
}

Explanation:

addFirst() and addLast(): Add elements to the front or end of the deque.
removeFirst() and removeLast(): Remove elements from the front or end of the deque.
Deque can act as both a stack (LIFO) or a queue (FIFO) depending on how you use the methods.

Conclusion

In this tutorial, we explored the Queue interface in Java and its common implementations:

LinkedList: Used as a queue in FIFO order.
PriorityQueue: Orders elements based on natural ordering or a custom comparator.
BlockingQueue: Useful in multithreading to handle blocking when adding or removing elements.
Deque: A double-ended queue allowing insertions and removals from both ends.
The Queue interface is a powerful tool for managing collections in a specific order, and its variations allow for great flexibility in a variety of use cases.

October 11, 2024 0 comment

Misc

Java List Interface Tutorial

written by 75ypsaw71

In Java, the List interface is part of the java.util package and is a sub-interface of the Collection interface. It represents an ordered collection of elements where duplicates are allowed.

Lists can dynamically grow or shrink in size, and you can access elements based on their index (position in the list).

The List interface is commonly used when you need to maintain the order of elements and allow duplicates. There are various classes that implement the List interface, such as ArrayList, LinkedList, Vector, and Stack.

This tutorial will cover how to use the List interface with different implementations, providing multiple examples to demonstrate key features.

1. Common Implementations of the List Interface

Here are the most commonly used classes that implement the List interface:

ArrayList: A resizable array that allows fast random access.
LinkedList: A doubly linked list that allows fast insertion and deletion.
Vector: Similar to ArrayList but is synchronized (thread-safe).
Stack: A subclass of Vector that follows the LIFO (Last-In-First-Out) principle.

2. Creating a List

You can create a List using different implementations. Below are examples of creating List objects using ArrayList and LinkedList:

Example: Creating a List

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListCreationExample {
    public static void main(String[] args) {
        // Creating a List using ArrayList
        List arrayList = new ArrayList<>();

        // Creating a List using LinkedList
        List linkedList = new LinkedList<>();

        // Adding elements
        arrayList.add("Apple");
        arrayList.add("Banana");
        linkedList.add("Carrot");
        linkedList.add("Date");

        // Display the lists
        System.out.println("ArrayList: " + arrayList);
        System.out.println("LinkedList: " + linkedList);
    }
}

Explanation:

We created two List objects: one using ArrayList and the other using LinkedList.
We added elements to both lists and displayed them.

Output:

ArrayList: [Apple, Banana]
LinkedList: [Carrot, Date]

3. Adding Elements to a List

The List interface provides several methods to add elements:

add(E element): Adds an element to the list.
add(int index, E element): Adds an element at the specified position in the list.

Example: Adding Elements to a List

import java.util.ArrayList;
import java.util.List;

public class AddElementsExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();

        // Adding elements at the end of the list
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // Adding an element at a specific index
        list.add(1, "JavaScript");

        // Displaying the list
        System.out.println("List after adding elements: " + list);
    }
}

Explanation:

We added elements to the list using add() and inserted an element at a specific position using add(int index, E element).

Output:

List after adding elements: [Java, JavaScript, Python, C++]

4. Accessing Elements in a List

You can access elements in a List using the get(int index) method, which retrieves the element at the specified index.

Example: Accessing Elements

import java.util.ArrayList;
import java.util.List;

public class AccessElementsExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();

        // Adding elements
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // Accessing elements using get()
        String firstElement = list.get(0);
        String secondElement = list.get(1);

        // Displaying the elements
        System.out.println("First element: " + firstElement);
        System.out.println("Second element: " + secondElement);
    }
}

Explanation:

We accessed elements at specific indexes using the get() method.

Output:

First element: Apple
Second element: Banana

5. Modifying Elements in a List

You can modify elements in a List using the set(int index, E element) method, which replaces the element at the specified index.

Example: Modifying Elements

import java.util.ArrayList;
import java.util.List;

public class ModifyElementsExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();

        // Adding elements
        list.add("Red");
        list.add("Green");
        list.add("Blue");

        // Modifying an element
        list.set(1, "Yellow");

        // Displaying the modified list
        System.out.println("List after modification: " + list);
    }
}

Explanation:

We replaced the element at index 1 with the new value “Yellow” using the set() method.

Output:

List after modification: [Red, Yellow, Blue]

6. Removing Elements from a List

You can remove elements from a List using:

remove(int index): Removes the element at the specified index.
remove(Object o): Removes the first occurrence of the specified element.

Example: Removing Elements

import java.util.ArrayList;
import java.util.List;

public class RemoveElementsExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();

        // Adding elements
        list.add("One");
        list.add("Two");
        list.add("Three");
        list.add("Four");

        // Removing an element by index
        list.remove(1);  // Removes "Two"

        // Removing an element by object
        list.remove("Four");

        // Displaying the modified list
        System.out.println("List after removals: " + list);
    }
}

Explanation:

We removed elements by index using remove(int index) and by object using remove(Object o).

Output:

List after removals: [One, Three]

7. Iterating Over a List

There are several ways to iterate over the elements of a List:

Using a for-each loop.
Using a for loop with an index.
Using a ListIterator.
Using a Stream (Java 8+).

Example: Iterating Over a List

import java.util.ArrayList;
import java.util.List;

public class IterateListExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 1. Using for-each loop
        System.out.println("Using for-each loop:");
        for (String fruit : list) {
            System.out.println(fruit);
        }

        // 2. Using for loop with index
        System.out.println("\nUsing for loop with index:");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 3. Using Java 8 Stream API
        System.out.println("\nUsing Stream API:");
        list.stream().forEach(System.out::println);
    }
}

Explanation:

We demonstrated three ways to iterate over the elements of the list: for-each loop, for loop with index, and the Java 8 Stream API.

Output:

Using for-each loop:
Apple
Banana
Cherry

Using for loop with index:
Apple
Banana
Cherry

Using Stream API:
Apple
Banana
Cherry

8. Sorting a List

You can sort a List using the Collections.sort() method for natural ordering or by providing a comparator for custom sorting.

Example: Sorting a List

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

public class SortListExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();
        list.add("Banana");
        list.add("Apple");
        list.add("Cherry");

        // Sorting the list in natural order
        Collections.sort(list);

        // Displaying the sorted list
        System.out.println("Sorted list: " + list);
    }
}

Explanation:

We used Collections.sort() to sort the list in natural alphabetical order.

Output:

Sorted list: [Apple, Banana, Cherry]

9. Checking if a List Contains an Element

You can check if a List contains a specific element using the contains(Object o) method.

Example: Checking for an Element

import java.util.ArrayList;
import java.util.List;

public class ContainsElementExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // Check if the list contains "Banana"
        boolean containsBanana = list.contains("Banana");
        System.out.println("Contains Banana? " + containsBanana);

        // Check if the list contains "Date"
        boolean containsDate = list.contains("Date");
        System.out.println("Contains Date? " + containsDate);
    }
}

Explanation:

We used contains() to check if the list contains specific elements.

Output:

Contains Banana? true
Contains Date? false

10. Converting a List to an Array

You can convert a List to an array using the toArray() method.

Example: Converting List to Array

import java.util.ArrayList;
import java.util.List;

public class ListToArrayExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // Convert list to array
        String[] array = list.toArray(new String[0]);

        // Display array elements
        System.out.println("Array elements:");
        for (String fruit : array) {
            System.out.println(fruit);
        }
    }
}

Explanation:

We converted the List to an array using toArray() and printed the elements of the array.

Output:

Array elements:
Apple
Banana
Cherry

Conclusion

The List interface in Java is a powerful collection that allows you to store and manipulate ordered elements. It is versatile and commonly used in many applications. Key points covered:

Common implementations: ArrayList, LinkedList, Vector, and Stack.
Adding, accessing, modifying, and removing elements: Simple methods like add(), get(), set(), and remove().
Iterating over a list: Various ways like for-each, for loop with index, and streams.
Sorting and checking for elements: Collections.sort() and contains().
Converting lists to arrays: Using toArray().

By mastering these methods, you can effectively work with the List interface to store and manipulate data in Java.

October 10, 2024 0 comment

Newer Posts

Older Posts