/** * 支持后进先出的栈,用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); }