[ADSx] - QStack & SQueue

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Stack;
import java.util.stream.IntStream;

class MyQueue<T> {
    /**
     * Queue made using a Two Stacks
     */
    Stack<T> stackOne;
    Stack<T> stackTwo;

    public MyQueue() {
        this.stackOne = new Stack<>();
        this.stackTwo = new Stack<>();
    }

    public boolean isEmpty() {
        return stackOne.isEmpty() && stackTwo.isEmpty();
    }

    public void enqueue(T element) {
        stackOne.push(element);
    }

    public T dequeue() {
        /* Initial Scenario */
        if (this.isEmpty()) {
            System.out.println("No elements");
            return null;
        }
        /* Running Scenario */
        if (stackTwo.isEmpty()) {
            while (!stackOne.isEmpty()) {
                T pop = stackOne.pop();
                stackTwo.push(pop);
            }
        }
        T pop = stackTwo.pop();
        return pop;
    }

    public T peek() {
        /* Initial Scenario */
        if (this.isEmpty()) {
            System.out.println("No elements");
            return null;
        }
        /* Running Scenario */
        return stackTwo.peek();
    }

    @Override
    public String toString() {
        return stackOne.toString() + " " + stackTwo.toString();
    }
}

class MyStack<T> {
    /**
     * Stack made using a Queue
     */
    Queue<T> queue;

    public MyStack() {
        this.queue = new java.util.LinkedList<>();
    }

    boolean isEmpty() {
        return queue.isEmpty();
    }

    void push(T element) {
        /* Initial Scenario */
        if (this.isEmpty()) {
            queue.add(element);
        }
        /* Running Scenario */
        else {
            queue.add(element);

            int sizeQueue = queue.size();
            for (int i = 0; i < sizeQueue - 1; i++) {
                T poll = queue.poll();
                queue.add(poll);
            }
        }
    }

    T pop() {
        /* Initial Scenario */
        if (this.isEmpty()) {
            System.out.println("No elements");
            return null;
        }
        /* Running Scenario */
        return queue.poll();
    }

    T peek() {
        /* Initial Scenario */
        if (this.isEmpty()) {
            System.out.println("No elements");
            return null;
        }
        /* Running Scenario */
        return queue.peek();
    }

    @Override
    public String toString() {
        return queue.toString();
    }
}

public class StackAndQueue {
    public static void main(String args[]) {
        //testStacks();
        testQueues();
    }

    public static void testStacks() {
        Stack<Integer> stack = new Stack<>();
        MyStack<Integer> myStack = new MyStack<>();
        IntStream.rangeClosed(1, 10).forEach(stack::push);
        IntStream.rangeClosed(1, 10).forEach(myStack::push);
        System.out.println(stack);
        System.out.println(myStack);

        System.out.printf("S: %-10d   mS: %-10d\n", stack.pop(), myStack.pop());
        System.out.printf("S: %-10d   mS: %-10d\n", stack.pop(), myStack.pop());
        System.out.printf("S: %-10d   mS: %-10d\n", stack.pop(), myStack.pop());

        stack.push(22);
        myStack.push(22);

        stack.push(33);
        myStack.push(33);

        stack.push(44);
        myStack.push(44);

        System.out.println(stack);
        System.out.println(myStack);

        System.out.printf("S: %-10d   mS: %-10d\n", stack.pop(), myStack.pop());
        System.out.printf("S: %-10d   mS: %-10d\n", stack.pop(), myStack.pop());
        System.out.printf("S: %-10d   mS: %-10d\n", stack.pop(), myStack.pop());

        System.out.println(stack);
        System.out.println(myStack);
    }

    public static void testQueues() {
        Queue<Integer> queue = new ArrayDeque<>();
        MyQueue<Integer> myQueue = new MyQueue<>();
        IntStream.rangeClosed(1, 10).forEach(queue::add);
        IntStream.rangeClosed(1, 10).forEach(myQueue::enqueue);

        System.out.println(queue);
        System.out.println(myQueue);

        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());
        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());
        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());

        queue.add(22);
        myQueue.enqueue(22);

        queue.add(33);
        myQueue.enqueue(33);

        queue.add(44);
        myQueue.enqueue(44);

        System.out.println(queue);
        System.out.println(myQueue);

        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());
        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());
        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());

        System.out.println(queue);
        System.out.println(myQueue);

        System.out.printf("[Peek] Q: %-10d   mQ: %-10d\n", queue.peek(), myQueue.peek());
        System.out.printf("[Peek] Q: %-10d   mQ: %-10d\n", queue.peek(), myQueue.peek());
        System.out.printf("[Peek] Q: %-10d   mQ: %-10d\n", queue.peek(), myQueue.peek());

        System.out.println(queue);
        System.out.println(myQueue);

        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());
        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());
        System.out.printf("Q: %-10d   mQ: %-10d\n", queue.poll(), myQueue.dequeue());

        System.out.println(queue);
        System.out.println(myQueue);

        System.out.printf("[Peek] Q: %-10d   mQ: %-10d\n", queue.peek(), myQueue.peek());
        System.out.printf("[Peek] Q: %-10d   mQ: %-10d\n", queue.peek(), myQueue.peek());
        System.out.printf("[Peek] Q: %-10d   mQ: %-10d\n", queue.peek(), myQueue.peek());

        System.out.println(queue);
        System.out.println(myQueue);
    }
}