Java: Implementation of double-chained list (deque) with callback, generics, exception and lambda [closed]

Let's start with Element :

public class Element<T> {
    private Element<T> next;
    private Element<T> prev;
    private T value;

    public Element(T v) {
        value = v;
    }

    public void setNext(Element<T> e) {
        this.next = e;
    }

    public Element<T> getNext() {
        return next;
    }

    public void setPrev(Element<T> e) {
        this.prev = e;
    }

    public Element<T> getPrev() {
        return prev;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        /*if(value != null) {
            System.out.println("the value is null!");
            return false;
        }*/
        return value;
    }
}

This return false; of getValue() is harmful. It prevents you from using generic types there. Also, if the content of Element is null , that the getValue() method returns that null .

The class EmptyListException :

public class EmptyListException extends Exception {
    public EmptyListException(String message) {
        super(message);
    }
}

Now the class Deque :

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

public class Deque<T> {
    private Element<T> head;
    private Element<T> tail; 

    public Deque() {
        head = tail = null;
    }

    public boolean isEmpty() {
        return head == null && tail == null;
    }

    public boolean isFull() {
        return false;
    }

    public List<T> toList() {
        List<T> list = new ArrayList<>();     
        Element<T> elementFirst = getFirst();          
        while (elementFirst != null) {
            T value = elementFirst.getValue(); 
            list.add(value);
            elementFirst = elementFirst.getNext();
        }
        return list;     
    }

    public void addFirst(T o) {
        System.out.println("Addited in first: " + o);
        Element<T> e = new Element<>(o);
        e.setNext(head); 

        if (head != null) {
            head.setPrev(e);  
        }
        head = e; 
        if (tail == null) {
            tail = e; 
        }
    }

    public void addLast(T o) {
        System.out.println("Addited in last: " + o);
        Element<T> e = new Element<>(o);
        e.setPrev(tail); 

        if (tail != null) {
            tail.setNext(e);
        }
        tail = e;
        if (head == null) {
            head = e;
        }
    }

    public T removeFirst() throws EmptyListException {
        if (this.isEmpty()) {
            throw new EmptyListException("The deque is empty!");
        }
        T o = head.getValue();
        head = head.getNext(); 
        if (head == null) { 
            tail = null;
        } else {
            head.setPrev(null); 
        }
        System.out.println("Removed in first: " + o);
        System.out.println("New head: " + head.getValue());
        return o;
    }

    public T removeLast() throws EmptyListException {
        if (this.isEmpty()) {
            throw new EmptyListException("The deque is empty!");
        }
        T o = tail.getValue();
        tail = tail.getPrev(); 
        if (tail == null) {
            head = null;
        } else {
            tail.setNext(null); 
        }
        System.out.println("Removed in last: " + o);
        System.out.println("New tail: " + tail.getValue());
        return o;
    }

    public void clear() {
        System.out.println("");
        System.out.println("Start clear... ");
        while (!this.isEmpty()) {
            this.removeFirst();
        }
        System.out.println("End clear");
        System.out.println("");
    }

    public void listing() {
        Element<T> e = head;
        System.out.println("");
        System.out.println("Start listing... ");
        while (e != null) {
            System.out.println("Value: " + e.getValue());
            e = e.getNext();
        }
        System.out.println("End listing");
        System.out.println("");
    }
}

Here are several things to note:

Finally, let's see your Main :

import java.util.List;

public class Main {
    public static void main(String[] args) { 
        Deque<String> deque = new Deque<>();

        while (true) {         
            System.out.println("Select the option\n 1->Add first:\n 2->Add last:\n3->List:\n 4->Remove first:\n 5->Remove last:\n 6->Clear:\n 7->Exit:\n");
            String option = scanner.next();
            if ("1".equals(option)) {
                System.out.println("Enter with the value: ");
                value = scanner.next();
                deque.addFirst(value);
            } else if ("2".equals(option)) {
                System.out.println("Enter with the value: ");
                value = scanner.next();
                deque.addLast(value);
            } else if ("3".equals(option)) {
                List<String> myList = deque.toList();
                System.out.println(myList);
                deque.listing();
            } else if ("4".equals(option)) {
                try {
                    deque.removeFirst();
                } catch (EmptyListException e) {
                    System.out.println(e.getMessage());
                }
            } else if ("5".equals(option)) {
                try {
                    deque.removeLast();
                } catch (EmptyListException e) {
                    System.out.println(e.getMessage());
                }
            } else if ("6".equals(option)) {
                deque.clear();
            } else if ("7".equals(option)) {
                break;
            } else {
                System.out.println("Invalid option");
            }
        }
    }
}

The remarks here are as follows: