java实现循环列表。循环列表的最后一个元素之后是第一个元素。注意，先写好抽象类 或者接口，再实现其功能。 1.1）判断满或者空； 1.2）添加数据：可以添加1个，也可以同时添加多个； 1.3）删除指定位置数据； 1.4）正向或者逆向遍历数据； 1.5）所有数据的存储顺序变为其逆序。

好的，我可以帮你解答这个问题。

首先，我们可以创建一个循环列表的抽象类或接口，定义其基本操作方法：

public abstract class AbstractCircularList<E> {
    protected int size;
    protected int capacity;

    public AbstractCircularList(int capacity) {
        this.capacity = capacity;
    }

    public abstract boolean isFull();

    public abstract boolean isEmpty();

    public abstract boolean add(E e);

    public abstract boolean addAll(Collection<? extends E> c);

    public abstract E remove(int index);

    public abstract void traverse(boolean reverse);

    public abstract void reverse();
}

其中，`isFull()` 和 `isEmpty()` 方法用于判断循环列表是否已满或为空；`add()` 和 `addAll()` 方法用于添加单个元素或多个元素；`remove()` 方法用于删除指定位置的元素；`traverse()` 方法用于正向或逆向遍历列表；`reverse()` 方法用于将列表中所有元素的存储顺序变为其逆序。

接下来，我们可以定义一个循环列表的实现类 `CircularList`，它继承自抽象类或实现接口，并实现其中的方法：

public class CircularList<E> extends AbstractCircularList<E> {
    private int head;
    private int tail;
    private E[] elements;

    public CircularList(int capacity) {
        super(capacity);
        elements = (E[]) new Object[capacity];
        head = 0;
        tail = 0;
    }

    @Override
    public boolean isFull() {
        return size == capacity;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean add(E e) {
        if (isFull()) {
            return false;
        }
        elements[tail] = e;
        tail = (tail + 1) % capacity;
        size++;
        return true;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        if (c.size() + size > capacity) {
            return false;
        }
        for (E e : c) {
            add(e);
        }
        return true;
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        int i = (head + index) % capacity;
        E e = elements[i];
        for (; i != tail; i = (i + 1) % capacity) {
            elements[i] = elements[(i + 1) % capacity];
        }
        tail = (tail - 1 + capacity) % capacity;
        size--;
        return e;
    }

    @Override
    public void traverse(boolean reverse) {
        if (reverse) {
            for (int i = tail - 1; i >= head; i--) {
                System.out.print(elements[i] + " ");
            }
            for (int i = capacity - 1; i >= tail; i--) {
                System.out.print(elements[i] + " ");
            }
        } else {
            for (int i = head; i < tail; i++) {
                System.out.print(elements[i] + " ");
            }
            for (int i = 0; i < head; i++) {
                System.out.print(elements[i] + " ");
            }
        }
        System.out.println();
    }

    @Override
    public void reverse() {
        for (int i = 0; i < size / 2; i++) {
            int j = (head + i) % capacity;
            int k = (tail - 1 - i + capacity) % capacity;
            E tmp = elements[j];
            elements[j] = elements[k];
            elements[k] = tmp;
        }
    }
}

其中，我们使用数组来存储循环列表的元素，`head` 和 `tail` 分别指向列表的头部和尾部。`add()` 方法实现了向列表尾部添加元素的操作，`addAll()` 方法实现了向列表尾部添加多个元素的操作，`remove()` 方法实现了删除指定位置元素的操作，`traverse()` 方法实现了正向或逆向遍历列表的操作，`reverse()` 方法实现了将列表所有元素的存储顺序变为其逆序的操作。

至此，我们就实现了一个简单的循环列表。可以通过以下代码进行测试：

CircularList<Integer> list = new CircularList<>(5);
list.add(1);
list.add(2);
list.add(3);
list.traverse(false); // 输出：1 2 3
list.reverse();
list.traverse(false); // 输出：3 2 1