Welcome to the practical segment of our Java programming journey! Today, we'll apply the knowledge from past lessons to solve two practice problems using advanced Java data structures: queues, deques, and sorted maps with custom class keys.

Consider an event-driven system, like a restaurant. Orders arrive, and they must be handled in the order they were received, following the First In, First Out (FIFO) principle. This principle makes it a perfect scenario for a queue or deque implementation in Java.

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

class Queue {
    private Deque<String> buffer;

    public Queue() {
        // Initializing an empty queue
        buffer = new ArrayDeque<>();
    }

    // Adding (enqueueing) an item to the queue
    public void enqueue(String val) {
        buffer.addLast(val);
    }

    // Removing (dequeuing) an item from the queue
    public String dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return buffer.removeFirst();
    }

    // Checking if the queue is empty
    public boolean isEmpty() {
        return buffer.isEmpty();
    }

    // Checking the size (number of items) in the queue
    public int size() {
        return buffer.size();
    }

    public static void main(String[] args) {
        Queue restaurantQueue = new Queue();

        restaurantQueue.enqueue("Order 1");
        restaurantQueue.enqueue("Order 2");

        System.out.println("Dequeued: " + restaurantQueue.dequeue());
        System.out.println("Dequeued: " + restaurantQueue.dequeue());
    }
}

This code demonstrates the creation and operation of a Queue class, which leverages ArrayDeque to efficiently implement a queue. The Queue class includes methods to enqueue (add) an item, dequeue (remove) an item, check if the queue is empty, and return the queue's size. Enqueue operations add an item to the end of the deque (simulating the arrival of a new order), while dequeue operations remove an item from the front (simulating the serving of an order), maintaining the First In, First Out (FIFO) principle.

We've mimicked a real-world system by implementing a queue using Java's ArrayDeque. The enqueuing of an item adheres to the FIFO principle, similar to the action of receiving a new order at the restaurant. The dequeuing serves an order, reflecting the preparation and delivery of the order.