java基础 -- 接口 Deque<E>

public static void main(String[] args) {
    add();
    addFirst();
    addLast();
    contains();
    descendingIterator();
    element();
    getFirst();
    getLast();
    iterator();
    offer();
    offerFirst();
    offerLast();
    peek();
    peekFirst();
    peekLast();
    poll();
    pollFirst();
    pollLast();
    pop();
    push();
    remove();
    removeFirst();
    removeFirstOccurrence();
    removeLast();
    removeLastOccurrence();
    size();
}

?

二.定义公共部分

//定义公共deque
private static Deque<Object> deque = new LinkedList<>();

//分割线
public static void division() {
    System.out.println("-------------------Division-------------------");
}

public static void add() {
    deque.add(2);
    deque.add(3);
    deque.add(4);
    deque.add("asd");
    deque.add("as");
    deque.add("we");

    System.out.println("测试add方法 >> 将指定元素插入此双端队列所表示的队列,在成功时返回 true:"+deque);
}

public static void addFirst() {
    division();
    System.out.println("当前deque:"+deque);

    deque.addFirst(1);
    System.out.println("测试addFirst方法 >> 将指定元素插入此双端队列的开头:"+deque);
}

public static void addLast() {
    division();
    System.out.println("当前deque:"+deque);

    deque.addLast(5);
    System.out.println("测试addLast方法 >> 将指定元素插入此双端队列的末尾:"+deque);
}

public static void contains() {
    division();
    System.out.println("当前deque:"+deque);

    boolean contains = deque.contains(5);
    System.out.println("测试contains方法 '5' >> 如果此双端队列包含指定元素，则返回 true:"+contains);
}

public static void descendingIterator() {
    division();
    System.out.println("当前deque:"+deque);

    Iterator<Object> objectIterator = deque.descendingIterator();
    System.out.println("测试descendingIterator方法  >> 返回以 逆向顺序 在此 双端队列 的元素上进行迭代的迭代器:"+objectIterator);
}

public static void element() {
    division();
    System.out.println("当前deque:"+deque);

    Object element = deque.element();

    System.out.println("测试element方法 >> 获取，但不移除此 双端队列 所表示的队列的头部:"+element);
    System.out.println("方法后deque:"+deque);
}

public static void getFirst()  {
    division();
    System.out.println("当前deque:"+deque);

    Object first = deque.getFirst();
    System.out.println("测试getFirst方法 >>  获取，但不移除此 双端队列 的第一个元素:"+first);
    System.out.println("方法后deque:"+deque);
}

public static void getLast()  {
    division();
    System.out.println("当前deque:"+deque);

    Object last = deque.getLast();
    System.out.println("测试getLast方法 >>  获取，但不移除此 双端队列 的最后一个元素:"+last);
    System.out.println("方法后deque:"+deque);
}

public static void iterator()  {
    division();
    System.out.println("当前deque:"+deque);

    Iterator<Object> iterator = deque.iterator();
    System.out.println("测试iterator方法 >>   返回以 恰当顺序 在此 双端队列 的元素上进行迭代的迭代器:"+iterator);
}

public static void offer() {
    division();
    System.out.println("当前deque:"+deque);

    boolean offer = deque.offer(6);

    System.out.println("测试offer方法 >> 将指定的元素插入此队列,当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常:"+deque);
    System.out.println("如果成功，则返回 true，如果当前没有可用的空间，则返回 false.与add方法一样");
}

public static void offerFirst() {
    division();
    System.out.println("当前deque:"+deque);

    boolean b = deque.offerFirst(0);
    System.out.println("测试offerFirst方法 >> 在不违反容量限制的情况下，将指定的元素插入此 双端队列 的 开头:"+deque);
}

public static void offerLast() {
    division();
    System.out.println("当前deque:"+deque);

    boolean b = deque.offerLast(7);
    System.out.println("测试offerLast方法 >> 在不违反容量限制的情况下，将指定的元素插入此 双端队列 的 末尾:"+deque);
}

public static void peek() {
    division();
    System.out.println("当前deque:"+deque);

    Object peek = deque.peek();
    System.out.println("测试peek方法 >> 获取 但不移除此 双端队列 的头；如果此队列为空，则返回 null:"+peek);
    System.out.println("方法后deque:"+deque);
}

public static void peekFirst() {
    division();
    System.out.println("当前deque:"+deque);

    Object o = deque.peekFirst();
    System.out.println("测试peekFirst方法 >> 获取，但不移除此 双端队列 的第一个元素；如果此双端队列为空，则返回 null:"+o);
    System.out.println("方法后deque:"+deque);
}

public static void peekLast() {
    division();
    System.out.println("当前deque:"+deque);

    Object o = deque.peekLast();
    System.out.println("测试peekLast方法 >> 获取，但不移除此 双端队列 的最后一个元素；如果此双端队列为空，则返回 null:"+o);
    System.out.println("方法后deque:"+deque);
}

public static void poll() {
    division();
    System.out.println("当前deque:"+deque);

    Object poll = deque.poll();
    System.out.println("测试poll方法 >> 获取 并 移除 此双端队列的头，如果此队列为空，则返回 null:"+poll);
    System.out.println("方法后deque:"+deque);
}

public static void pollFirst() {
    division();
    System.out.println("当前deque:"+deque);

    Object o = deque.pollFirst();
    System.out.println("测试pollFirst方法 >>  获取 并 移除 此 双端队列 的第一个元素；如果此双端队列为空，则返回 null:"+o);
    System.out.println("方法后deque:"+deque);
}

public static void pollLast() {
    division();
    System.out.println("当前deque:"+deque);

    Object o = deque.pollLast();
    System.out.println("测试pollLast方法 >>  获取 并 移除 此 双端队列 的最后一个元素；如果此双端队列为空，则返回 null:"+o);
    System.out.println("方法后deque:"+deque);
}

public static void pop() {
    division();
    System.out.println("当前deque:"+deque);

    Object pop = deque.pop();
    System.out.println("测试pop方法 >>  从此 双端队列 所表示的堆栈中 弹出 一个元素:"+pop);
    System.out.println("方法后deque:"+deque);
}

public static void push() {
    division();
    System.out.println("当前deque:"+deque);

    deque.push("天");
    System.out.println("测试push方法 >>   将一个元素 推入 此 双端队列 所表示的堆栈，如果可以直接这样做而不违反容量限制的话:"+deque);
}

public static void remove() {
    division();
    System.out.println("当前deque:"+deque);

    Object remove = deque.remove(3);
    System.out.println("测试remove方法 >> 从此 双端队列 中 移除 第一次出现的指定元素,成功则返回 true:"+remove);
    System.out.println("方法后deque:"+deque);
}

public static void removeFirst()  {
    division();
    System.out.println("当前deque:"+deque);

    Object o = deque.removeFirst();
    System.out.println("测试removeFirst方法 >> 获取 并 移除 此 双端队列 第一个元素:"+o);
    System.out.println("方法后deque:"+deque);
}

public static void removeFirstOccurrence()  {
    division();
    System.out.println("当前deque:"+deque);

    boolean b = deque.removeFirstOccurrence(5);
    System.out.println("测试removeFirstOccurrence方法 >> 从此 双端队列 移除 第一次出现的指定元素,成功则返回 true:"+b);
    System.out.println("方法后deque:"+deque);
}

public static void removeLast()  {
    division();
    System.out.println("当前deque:"+deque);

    Object o = deque.removeLast();
    System.out.println("测试removeLast方法 >> 获取 并 移除 此 双端队列 的最后一个元素:"+o);
    System.out.println("方法后deque:"+deque);
}

public static void removeLastOccurrence()  {
    division();
    System.out.println("当前deque:"+deque);

    boolean b = deque.removeLastOccurrence("as");
    System.out.println("测试removeLastOccurrence方法 >> 从此 双端队列 移除 最后一次出现的指定元素:"+b);
    System.out.println("方法后deque:"+deque);
}

public static void size()  {
    division();
    System.out.println("当前deque:"+deque);
    ;
    System.out.println("测试size方法 >> 返回此双端队列的元素数:"+deque.size());
}