Estoy implementando una estructura de datos cíclicamente DoublyLinkedList. Al igual que una lista individualmente vinculada, los nodos en una lista doblemente vinculada tienen una referencia al siguiente nodo, pero a diferencia de una lista individualmente vinculada, los nodos en una lista doblemente vinculada también tienen una referencia al nodo anterior.

Adicionalmente, debido a que la lista es "cíclica", la referencia "siguiente" en el último nodo de la lista apunta al primer nodo de la lista y la referencia "anterior" en el primer nodo de la lista apunta al último nodo en la lista

Necesito ayuda para comenzar mi método de obtención, he estado buscando y no pude encontrar nada que pudiera ayudarme ya que estoy trabajando con un tipo genérico. Necesito devolver E y todos los demás ejemplos me lo muestran con int como ejemplo. Aquí está mi código:

public class DoublyLinkedList<E>
{
private Node first;
private int size;

@SuppressWarnings("unchecked")
public void add(E value)
{
    if (first == null)
    {
        first = new Node(value, null, null);
        first.next = first;
        first.prev = first;
    }
    else
        {
        first.prev.next = new Node(value, first, first.prev);
        first.prev = first.prev.next;
    }
    size++;
}
private class Node<E>
{
    private E data;
    private Node next;
    private Node prev;

    public Node(E data, Node next, Node prev)
    {
        this.data = data;
        this.next = next;
        this.prev = prev;
    }
}
@SuppressWarnings("unchecked")
public void add(int index, E value)
{
    if (first.data == null)
    {
        throw new IndexOutOfBoundsException();
    } else if (index == 0)
    {
        first = new Node(value, first.next, first.prev);
    }
    else
        {
        Node current = first;
        for (int i = 0; i < index - 1; i++)
        {
            current = current.next;
        }
        current.next = new Node(value, current.next, current.prev);
    }
}
@SuppressWarnings("unchecked")
public void remove(int index)
{
    if (first.data == null)
    {
        throw new IndexOutOfBoundsException();
    }
    else if (index == 0)
    {
        first = first.next;
    }
    else
        {
            Node current = first.next;
            for (int i = 0; i < index - 1; i++)
        {
            current = current.next;
        }
        current.next = current.next.next;
    }
    size--;
}

No puedo pensar en una forma de comenzar con esto, pero básicamente lo que este método debería hacer es devolver el elemento en el índice especificado en la lista. Si el parámetro de índice no es válido, se debe lanzar una excepción IndexOutOfBoundsException.

public E get(int index)
{

}

Además, mi método de eliminación no es preciso, pero lo resolveré yo mismo, solo necesito ayuda con mi método de obtención.