How to use

asLifoQueue

method

in

java.util.Collections

/**
 * 支持后进先出的栈，用ArrayDeque实现, 经过Collections#asLifoQueue()转换顺序
 * 
 * 需设置初始长度，默认为16，数组满时成倍扩容
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createStack(int initSize) {
  return Collections.asLifoQueue(new ArrayDeque<E>(initSize));
}

/**
 * 支持后进先出的栈，用ArrayDeque实现, 经过Collections#asLifoQueue()转换顺序
 * 
 * 需设置初始长度，默认为16，数组满时成倍扩容
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createStack(int initSize) {
  return Collections.asLifoQueue(new ArrayDeque<E>(initSize));
}

  @Override
  protected Queue<TimerEntry> initialValue() {
    return Collections.asLifoQueue(new LinkedList<TimerEntry>());
  }
};

/**
 * 支持后进先出的无阻塞的并发栈，用ConcurrentLinkedDeque实现，经过Collections#asLifoQueue()转换顺序
 * 
 * 另对于BlockingQueue接口， JDK暂无Lifo倒转实现，因此只能直接使用未调转顺序的LinkedBlockingDeque
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createConcurrentStack() {
  return (Queue<E>) Collections.asLifoQueue(QueueUtil.newConcurrentNonBlockingDeque());
}

/**
 * 支持后进先出的无阻塞的并发栈，用ConcurrentLinkedDeque实现，经过Collections#asLifoQueue()转换顺序
 * 
 * 另对于BlockingQueue接口， JDK暂无Lifo倒转实现，因此只能直接使用未调转顺序的LinkedBlockingDeque
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createConcurrentStack() {
  return (Queue<E>) Collections.asLifoQueue(QueueUtil.newConcurrentNonBlockingDeque());
}

/**
 * 支持后进先出的栈，用ArrayDeque实现, 经过Collections#asLifoQueue()转换顺序
 * 
 * 需设置初始长度，默认为16，数组满时成倍扩容
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createStack(int initSize) {
  return Collections.asLifoQueue(new ArrayDeque<E>(initSize));
}

/**
 * 支持后进先出的栈，用ArrayDeque实现, 经过Collections#asLifoQueue()转换顺序
 * 
 * 需设置初始长度，默认为16，数组满时成倍扩容
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createStack(int initSize) {
  return Collections.asLifoQueue(new ArrayDeque<E>(initSize));
}

  @Override
  public <S extends AbstractBlueFringePTAState<?, ?, S>> Queue<PTATransition<S>> createWorklist() {
    return Collections.asLifoQueue(new ArrayDeque<>());
  }
}

/**
 * 支持后进先出的栈，用ArrayDeque实现, 经过Collections#asLifoQueue()转换顺序
 * 
 * 需设置初始长度，默认为16，数组满时成倍扩容
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createStack(int initSize) {
  return Collections.asLifoQueue(new ArrayDeque<E>(initSize));
}

  @Override
  protected Queue<TimerEntry> initialValue() {
    return Collections.asLifoQueue(new LinkedList<TimerEntry>());
  }
};

  public static <T> Queue<T> stack() {
    return Collections.asLifoQueue(new ArrayDeque<>());
  }
}

 Queue<Integer> arrayLifoQueue = Collections.asLifoQueue(new ArrayDeque<Integer>());
Queue<Integer> linkedListLifoQueue = Collections.asLifoQueue(new LinkedList<Integer>());

 Queue<Object> stack = Collections.asLifoQueue(new ArrayDeque<Object>());
stack.add("red");
stack.add(Color.GREEN);
stack.add(stack);

/**
 * 支持后进先出的无阻塞的并发栈，用ConcurrentLinkedDeque实现，经过Collections#asLifoQueue()转换顺序
 * 
 * 另对于BlockingQueue接口， JDK暂无Lifo倒转实现，因此只能直接使用未调转顺序的LinkedBlockingDeque
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createConcurrentStack() {
  return (Queue<E>) Collections.asLifoQueue(QueueUtil.newConcurrentNonBlockingDeque());
}

/**
 * 支持后进先出的并发栈，用ConcurrentLinkedDeque实现，经过Collections#asLifoQueue()转换顺序
 * 
 * 另对于BlockingQueue接口， JDK暂无Lifo倒转实现，因此只能直接使用未调转顺序的LinkedBlockingDeque
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createConcurrentStack() {
  return (Queue<E>) Collections.asLifoQueue(newConcurrentNonBlockingDeque());
}

/**
 * 支持后进先出的并发栈，用ConcurrentLinkedDeque实现，经过Collections#asLifoQueue()转换顺序
 * 
 * 另对于BlockingQueue接口， JDK暂无Lifo倒转实现，因此只能直接使用未调转顺序的LinkedBlockingDeque
 * 
 * @see Collections#asLifoQueue()
 */
public static <E> Queue<E> createConcurrentStack() {
  return (Queue<E>) Collections.asLifoQueue(newConcurrentNonBlockingDeque());
}

private Queue<AnswerNode> getInitialNodes(List<PlanRecord> plans ) {
  final Queue<AnswerNode> queue = Collections.asLifoQueue( new ArrayDeque<AnswerNode>() );
  for ( PlanRecord p : plans ) queue.add( new AnswerNode( p , null ) );
  return queue;
}

/**
 * @param stage the annotation that specifies this stage
 * @param mode  execution order
 */
public DefaultStager(Class<A> stage, Order mode) {
  this.stage = stage;
  Queue<Stageable> localStageables;
  switch (mode) {
    case FIRST_IN_FIRST_OUT: {
      localStageables = new ArrayDeque<>();
      break;
    }
    case FIRST_IN_LAST_OUT: {
      localStageables = Collections.asLifoQueue(new ArrayDeque<Stageable>());
      break;
    }
    default: {
      throw new IllegalArgumentException("Unknown mode: " + mode);
    }
  }
  stageables = localStageables;
}

/**
 * Finish the cloning of the copy
 * Ensure than transient fields store the good values
 * @return
 */
private Object readResolve() {
  if (!test) {
    timer = Properties.metrics.timer("Allevents.timer").time();
    Properties.metrics.counter("Allevents.inflight").inc();
  } else {
    timer = null;
  }
  processors = new LinkedList<>();
  wevent = null;
  timersStack = Collections.asLifoQueue(new ArrayDeque<PausingContext>());
  pipelineNames = new ArrayDeque<>();
  return this;
}

 public class Practice15 {

public static void main(String[] args) {


  Deque<Integer> dd=new ArrayDeque<Integer>();

  dd.offerFirst(123);

  dd.offerFirst(258);

  dd.offerFirst(125);

  System.out.println(dd);

  Queue<Integer> q1=Collections.asLifoQueue(dd);

  System.out.println(q1);

}