Java Collections checkedQueue() Method with Examples

The checkedQueue() method in the Java Collections Framework is useful for making queues type safe at the runtime and therefore it is a very effective and important utility and it is for this reason that the checkedQueue() method is in the Collections class and can therefore be utilized as a way of creating a dynamic type safe view on a given queue. It means that any attempts to insert elements of the wrong type into the queue will cause a ClassCastException.

Method Signature

<E>: It is a generic type parameter which can act as a type and contain other parameters. The <E> describes that the method can work with any object of the type E, which is the type of elements in the queue.

Queue<E>: It is the return type of the method. It means that the method returns a Queue of type < E >.

checkedQueue: It refers to the name of the method.

Queue<E> queue: It is the first parameter of the method. It is a Queue that holds elements of type E. The method creates a type-safe view of this queue.

Class<E> type: It is the second parameter of the method. It is a Class object representing the type of elements in the queue. This parameter helps enforce type safety by ensuring that only elements of the specified type E can be added to the queue.

Example 1: Creating a type-safe view of the List

In this example, we create a regular Queue and use the Collections.checkedQueue() to wrap the queue, specifying the type of elements it should hold and add elements to the type-safe queue. Demonstrate what happens when an attempt is made to add an element of an incorrect type. Iterate Over the Queue of elements to show the correct usage.

Filename: CheckedQueueExample.java

import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;
// Custom class to demonstrate type safety
class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}
public class CheckedQueueExample {
    public static void main(String[] args) {
        // Step 1: Create a normal queue
        Queue<Person> queue = new LinkedList<>();
        // Step 2: Wrap the queue with checkedQueue to ensure only Person objects are allowed
        Queue<Person> checkedQueue = Collections.checkedQueue(queue, Person.class);
        // Step 3: Add elements to the checked queue
        checkedQueue.add(new Person("Alice", 30));
        checkedQueue.add(new Person("Bob", 25));
        // Step 4: Attempt to add an invalid element
        // Uncommenting the following lines will cause a ClassCastException at runtime
        // Queue rawQueue = checkedQueue; // Raw type usage
        // rawQueue.add("Not a Person"); // Trying to add a string to a queue of Person objects
        try {
            // Simulating an incorrect addition to demonstrate the exception
            Queue rawQueue = checkedQueue; // Raw type usage
            rawQueue.add("Not a Person"); // Trying to add a string to a queue of Person objects
        } catch (ClassCastException e) {
            System.out.println("Caught a ClassCastException: " + e.getMessage());
        }
        // Step 5: Iterate through the queue
        for (Person person : checkedQueue) {
            System.out.println(person);
        }
        // Adding another valid Person object
        checkedQueue.add(new Person("Charlie", 40));
        // Iterate again to show the newly added element
        System.out.println("After adding another person:");
        for (Person person : checkedQueue) {
            System.out.println(person);
        }
    }
}

Output

Caught a ClassCastException: Attempt to insert class java.lang.String element into collection with element type class Person
Alice (30)
Bob (25)
After adding another person:
Alice (30)
Bob (25)
Charlie (40)

Example 2: Basic Usage with Integer Queue

In this example, we will create a regular queue for Integer elements. Wrap the queue using Collections.checkedQueue() to ensure type safety. Add valid Integer elements to the queue. Attempt to add an invalid element to demonstrate the type safety provided by checkedQueue. Iterate through the queue to display the elements.

Filename: IntegerCheckedQueueExample.java

import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;
public class IntegerCheckedQueueExample {
    public static void main(String[] args) {
        // Step 1: Create a normal queue
        Queue<Integer> queue = new LinkedList<>();
        // Step 2: Wrap the queue with checkedQueue to ensure only Integer elements are allowed
        Queue<Integer> checkedQueue = Collections.checkedQueue(queue, Integer.class);
        // Step 3: Add elements to the checked queue
        checkedQueue.add(1);
        checkedQueue.add(2);
        checkedQueue.add(3);
        // Step 4: Attempt to add an invalid element
        try {
            Queue rawQueue = checkedQueue; // Raw type usage
            rawQueue.add("Not an Integer"); // Trying to add a string to a queue of Integers
        } catch (ClassCastException e) {
            System.out.println("Caught a ClassCastException: " + e.getMessage());
        }
        // Step 5: Iterate through the queue
        for (Integer number : checkedQueue) {
            System.out.println(number);
        }
    }
}

Output

Caught a ClassCastException: Attempt to insert class java.lang.String element into collection with element type class java.lang.Integer
1
2
3

Example 3: Custom Class with Additional Operations

In this example, we demonstrate the use of Collections.checkedQueue() with a custom class, Task, to enforce type safety and perform additional queue operations. The Task class represents a unit of work with a description and priority, this example includes adding tasks, processing tasks, and ensuring type safety when interacting with the queue.

Filename: TaskCheckedQueueExample.java

import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;
// Step 1: Define the Custom Class
class Task {
    String description;
    int priority;
    Task(String description, int priority) {
        this.description = description;
        this.priority = priority;
    }
    @Override
    public String toString() {
        return "Task: " + description + ", Priority: " + priority;
    }
}
public class TaskCheckedQueueExample {
    public static void main(String[] args) {
        // Step 2: Create a normal queue
        Queue<Task> queue = new LinkedList<>();
        // Step 3: Wrap the queue with checkedQueue to ensure only Task objects are allowed
        Queue<Task> checkedQueue = Collections.checkedQueue(queue, Task.class);
        // Step 4: Add elements to the checked queue
        checkedQueue.add(new Task("Finish report", 1));
        checkedQueue.add(new Task("Email client", 2));
        checkedQueue.add(new Task("Prepare presentation", 3));
        // Step 5: Attempt to add an invalid element
        try {
            Queue rawQueue = checkedQueue; // Raw type usage
            rawQueue.add("Not a Task"); // Trying to add a string to a queue of Tasks
        } catch (ClassCastException e) {
            System.out.println("Caught a ClassCastException: " + e.getMessage());
        }
        // Step 6: Iterate through the queue
        System.out.println("Current tasks in the queue:");
        for (Task task : checkedQueue) {
            System.out.println(task);
        }
        // Step 7: Remove and display the head of the queue
        Task nextTask = checkedQueue.poll();
        System.out.println("Next task to process: " + nextTask);
        // Additional Operations
        // Add more tasks
        checkedQueue.add(new Task("Call supplier", 4));
        checkedQueue.add(new Task("Update website", 5));
        // Display all tasks after adding more
        System.out.println("Tasks after adding more:");
        for (Task task : checkedQueue) {
            System.out.println(task);
        }
        // Remove another task and display
        Task anotherTask = checkedQueue.poll();
        System.out.println("Next task to process: " + anotherTask);
        // Check the remaining tasks
        System.out.println("Remaining tasks in the queue:");
        for (Task task : checkedQueue) {
            System.out.println(task);
        }
    }
}

Output

Caught a ClassCastException: Attempt to insert class java.lang.String element into collection with element type class Task
Current tasks in the queue:
Task: Finish report, Priority: 1
Task: Email client, Priority: 2
Task: Prepare presentation, Priority: 3
Next task to process: Task: Finish report, Priority: 1
Tasks after adding more:
Task: Email client, Priority: 2
Task: Prepare presentation, Priority: 3
Task: Call supplier, Priority: 4
Task: Update website, Priority: 5
Next task to process: Task: Email client, Priority: 2
Remaining tasks in the queue:
Task: Prepare presentation, Priority: 3
Task: Call supplier, Priority: 4
Task: Update website, Priority: 5

Example 4: Mixed Operations with PriorityQueue

In this example, we will explore how to use Collections.checkedQueue() with a PriorityQueue. The PriorityQueue is a type of queue in Java that orders its elements based on their natural ordering or by a custom comparator provided at the time of queue construction. We will use a custom class, Task, to represent items in the queue and demonstrate various operations while ensuring type safety with Collections.checkedQueue().

Filename: TaskCheckedPriorityQueueExample.java

import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Queue;
// Step 1: Define the Custom Class
class Task implements Comparable<Task> {
    String description;
    int priority;
    Task(String description, int priority) {
        this.description = description;
        this.priority = priority;
    }
    @Override
    public int compareTo(Task other) {
        return Integer.compare(this.priority, other.priority);
    }
    @Override
    public String toString() {
        return "Task: " + description + ", Priority: " + priority;
    }
}
public class TaskCheckedPriorityQueueExample {
    public static void main(String[] args) {
        // Step 2: Create a normal PriorityQueue
        Queue<Task> queue = new PriorityQueue<>();
        // Step 3: Wrap the queue with checkedQueue to ensure only Task objects are allowed
        Queue<Task> checkedQueue = Collections.checkedQueue(queue, Task.class);
        // Step 4: Add elements to the checked queue
        checkedQueue.add(new Task("Finish report", 1));
        checkedQueue.add(new Task("Email client", 2));
        checkedQueue.add(new Task("Prepare presentation", 3));
        // Step 5: Attempt to add an invalid element
        try {
            Queue rawQueue = checkedQueue; // Raw type usage
            rawQueue.add("Not a Task"); // Trying to add a string to a queue of Tasks
        } catch (ClassCastException e) {
            System.out.println("Caught a ClassCastException: " + e.getMessage());
        }
        // Step 6: Iterate through the queue
        System.out.println("Current tasks in the queue:");
        for (Task task : checkedQueue) {
            System.out.println(task);
        }
        // Remove and display the head of the queue
        Task nextTask = checkedQueue.poll();
        System.out.println("Next task to process: " + nextTask);
        // Additional Operations
        // Add more tasks
        checkedQueue.add(new Task("Call supplier", 4));
        checkedQueue.add(new Task("Update website", 5));
        // Display all tasks after adding more
        System.out.println("Tasks after adding more:");
        for (Task task : checkedQueue) {
            System.out.println(task);
        }
        // Remove another task and display
        Task anotherTask = checkedQueue.poll();
        System.out.println("Next task to process: " + anotherTask);
        // Check the remaining tasks
        System.out.println("Remaining tasks in the queue:");
        for (Task task : checkedQueue) {
            System.out.println(task);
        }
    }
}

Output

Caught a ClassCastException: Attempt to insert class java.lang.String element into collection with element type class Task
Current tasks in the queue:
Task: Finish report, Priority: 1
Task: Email client, Priority: 2
Task: Prepare presentation, Priority: 3
Next task to process: Task: Finish report, Priority: 1
Tasks after adding more:
Task: Email client, Priority: 2
Task: Prepare presentation, Priority: 3
Task: Call supplier, Priority: 4
Task: Update website, Priority: 5
Next task to process: Task: Email client, Priority: 2
Remaining tasks in the queue:
Task: Prepare presentation, Priority: 3
Task: Update website, Priority: 5
Task: Call supplier, Priority: 4

Example 5: Handling Different Data Types with PriorityBlockingQueue

In this example, a PriorityBlockingQueue is created to manage tasks with different data types. The queue is wrapped with Collections.checkedQueue() to enforce type safety, ensuring only GenericTask objects can be added. Various tasks with different data types (String, Integer, Double) are added to the queue. The tasks in the queue are displayed and then processed in priority order and the processed tasks are displayed.

Filename: CheckedQueueGenericTaskExample.java

import java.util.Collections;
import java.util.Queue;
import java.util.concurrent.PriorityBlockingQueue;
// GenericTask class to handle different types of tasks with priority
class GenericTask<T> implements Comparable<GenericTask<T>> {
    T data;
    int priority;
    GenericTask(T data, int priority) {
        this.data = data;
        this.priority = priority;
    }
    @Override
    public int compareTo(GenericTask<T> other) {
        return Integer.compare(this.priority, other.priority);
    }
    @Override
    public String toString() {
        return "Task: " + data + ", Priority: " + priority;
    }
}
public class CheckedQueueGenericTaskExample {
    public static void main(String[] args) {
        // Create a PriorityBlockingQueue-based Queue
        Queue<GenericTask<?>> queue = new PriorityBlockingQueue<>();
        // Wrap the queue with checkedQueue to ensure only GenericTask objects are allowed
        @SuppressWarnings("unchecked")
        Queue<GenericTask<?>> checkedQueue = Collections.checkedQueue(queue, (Class<GenericTask<?>>) (Class<?>) GenericTask.class);
        // Attempt to add an invalid element
        try {
            Queue rawQueue = checkedQueue; // Raw type usage
            rawQueue.add("Not a GenericTask"); // Trying to add a String to a queue of GenericTasks
        } catch (ClassCastException e) {
            System.out.println("Caught a ClassCastException: " + e.getMessage());
        }
        // Add elements to the queue
        checkedQueue.add(new GenericTask<>("Finish report", 1));
        checkedQueue.add(new GenericTask<>(123, 2)); // Integer data
        checkedQueue.add(new GenericTask<>(45.67, 3)); // Double data
        // Display elements
        System.out.println("Tasks in the queue:");
        for (GenericTask<?> task : checkedQueue) {
            System.out.println(task);
        }
        // Process tasks in priority order
        System.out.println("\nProcessing tasks in priority order:");
        while (!checkedQueue.isEmpty()) {
            System.out.println("Processed: " + checkedQueue.poll());
        }
    }
}

Output

Caught a ClassCastException: Attempt to insert class java.lang.String element into collection with element type class GenericTask
Tasks in the queue:
Task: Finish report, Priority: 1
Task: 123, Priority: 2
Task: 45.67, Priority: 3
Processing tasks in priority order:
Processed: Task: Finish report, Priority: 1
Processed: Task: 123, Priority: 2
Processed: Task: 45.67, Priority: 3

Applications

1. Input Validation in User Interfaces

When building graphical user interfaces (GUIs), user input often needs to be validated before processing. By using checkedQueue, you can ensure that only valid data types are accepted in input queues, preventing runtime errors.

2. Message Queues in Concurrent Systems

In multi-threaded applications where, multiple threads are producing and consuming messages, ensuring type safety in message queues is crucial. checkedQueue can help prevent data corruption or incorrect processing by enforcing type constraints.

3. Event Handling in GUI Frameworks

GUI frameworks often use event queues to manage user interactions and system events. By wrapping event queues with checkedQueue, you can ensure that only valid event objects are processed, reducing the risk of errors.

4. Task Scheduling in Job Queues

Job scheduling systems often use queues to manage tasks to be executed at specific times or intervals. checkedQueue can help enforce type safety in job queues, ensuring that only valid job objects are scheduled for execution.

Next TopicString-literal-vs-string-object-in-java

← prev next →