public static void main(String[] args) { Deque<Integer> ints = new Deque<Integer>(); assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(1); assert ints.size() == 1; assert !ints.isEmpty(); int val = ints.removeFirst(); assert val == 1; assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(2); assert ints.size() == 1; assert !ints.isEmpty(); val = ints.removeLast(); assert val == 2; assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(3); ints.addFirst(2); ints.addFirst(1); ints.addLast(4); ints.addLast(5); ints.addLast(6); assert ints.size() == 6; assert !ints.isEmpty(); for (int value : ints) { StdOut.print(value + " "); } StdOut.println(); while (!ints.isEmpty()) { StdOut.println(ints.removeLast()); } assert ints.size() == 0; assert ints.isEmpty(); for (int i = 0; i < 10; ++i) { ints.addFirst(i); } for (int i = 0; i < 10; ++i) { assert ints.size() == 10 - i; ints.removeLast(); } assert ints.size() == 0; }
@Test public void testRemove() { Deque<String> deque = new Deque<String>(); deque.addFirst(new String("test")); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); deque.removeLast(); deque.removeFirst(); assertTrue(deque.size() == 1); deque.removeLast(); assertTrue(deque.size() == 0); }
@Test public void testAddLastAndRemoveLastAll() { deque.addLast("1"); deque.addLast("2"); deque.addLast("3"); deque.addLast("4"); assertEquals(deque.removeLast(), "4"); assertEquals(deque.removeLast(), "3"); assertEquals(deque.removeLast(), "2"); assertEquals(deque.removeLast(), "1"); }
@Test(expected = NoSuchElementException.class) public void testRemoveLastFromEmptyDeque() { Deque<Integer> deque = new Deque<Integer>(); int count = 10; for (int i = 0; i < count; i++) { deque.addLast(i); } for (int i = 0; i < count; i++) { deque.removeLast(); } deque.removeLast(); // should throw }
@Test public void Deque_addLast_removeLast_AddsRemovesTwo() { deque.addLast("firstString"); deque.addLast("secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 2); String returnedString = deque.removeLast(); assertEquals(returnedString, "secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 1); returnedString = deque.removeLast(); assertEquals(returnedString, "firstString"); assertTrue(deque.isEmpty()); assertEquals(deque.size(), 0); }
@Test(expected = NoSuchElementException.class) public void Deque_addLast_removeFirst_throwsIfEmpty() { deque.addFirst("firstString"); deque.addFirst("secondString"); deque.removeLast(); deque.removeLast(); deque.removeFirst(); }
@Test public void test10() { deque = new Deque<String>(); deque.addFirst("1"); deque.addFirst("2"); deque.addFirst("3"); deque.addFirst("4"); assertEquals(deque.removeLast(), "1"); assertEquals(deque.removeFirst(), "4"); deque.addLast("7"); assertEquals(deque.removeLast(), "7"); assertEquals(deque.removeLast(), "2"); assertEquals(deque.removeLast(), "3"); assertEquals(deque.size(), 0); }
public static void main(String[] args) { Deque<Integer> di = new Deque<Integer>(); fillTest(di); print(di); while (di.size() != 0) printnb(di.removeFirst() + " "); print(); fillTest(di); while (di.size() != 0) printnb(di.removeLast() + " "); }
@Test public void testAddLastAndAddFirstWithRemoveLast() { deque.addLast("4"); deque.addLast("5"); deque.addLast("6"); deque.addLast("7"); deque.addFirst("3"); deque.addFirst("2"); deque.addFirst("1"); assertEquals(deque.removeLast(), "7"); assertEquals(deque.removeLast(), "6"); assertEquals(deque.removeLast(), "5"); assertEquals(deque.removeLast(), "4"); assertEquals(deque.removeLast(), "3"); assertEquals(deque.removeLast(), "2"); assertEquals(deque.removeLast(), "1"); }
@Test public void testAdditionOrdered() { Deque<Integer> deque = new Deque<Integer>(); for (int i = 0; i < 10; i++) { deque.addFirst(i); } for (int i = 0; i < 10; i++) { assertEquals(deque.removeLast(), new Integer(i)); } }
public int[] maxSlidingWindow(int[] nums, int k) { if (nums == null || nums.length == 0) return new int[0]; int[] result = new int[nums.length + 1 - k]; Deque<Integer> dq = new LinkedList<Integer>(); for (int i = 0, j = 1 - k; i < nums.length; i++, j++) { if (!dq.isEmpty() && dq.peekFirst() <= i - k) dq.removeFirst(); while (!dq.isEmpty() && nums[dq.peekLast()] <= nums[i]) dq.removeLast(); dq.addLast(i); if (j >= 0) result[j] = nums[dq.peekFirst()]; } return result; }
public static void main(String[] args) { // unit testing Deque<String> d = new Deque<String>(); d.addFirst("sant"); d.addLast("prakash"); d.addFirst("sid"); for (String s : d) StdOut.println(s); StdOut.println("removing last"); StdOut.println(d.removeLast()); StdOut.println("resulting list"); for (String s : d) StdOut.println(s); StdOut.println("removing fist"); StdOut.println(d.removeFirst()); StdOut.println("resulting list"); for (String s : d) StdOut.println(s); }
private List<List<Integer>> help1(TreeNode root) { List<List<Integer>> res = new ArrayList<List<Integer>>(); if (root == null) { return res; } Deque<TreeNode> current = new LinkedList<>(); Deque<TreeNode> next = new LinkedList<>(); boolean isOdd = true; current.add(root); while (!current.isEmpty()) { int size = current.size(); List<Integer> level = new LinkedList<Integer>(); if (isOdd) { for (int i = 0; i < size; i++) { TreeNode top = current.removeFirst(); level.add(top.val); if (top.left != null) { next.addLast(top.left); } if (top.right != null) { next.addLast(top.right); } } } else { for (int i = 0; i < size; i++) { TreeNode top = current.removeLast(); level.add(top.val); if (top.right != null) { next.addFirst(top.right); } if (top.left != null) { next.addFirst(top.left); } } } isOdd = !isOdd; current = next; res.add(level); } return res; }
@Test public void testIsEmpty() { Deque<String> deque = new Deque<String>(); assertTrue(deque.isEmpty()); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); deque.addLast(new String("test last")); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); assertFalse(deque.isEmpty()); deque.removeFirst(); deque.removeFirst(); deque.removeFirst(); deque.removeLast(); deque.removeLast(); assertTrue(deque.isEmpty()); }
private static void recursiveCompile( EvalNode evalNode, StatementContext context, Set<String> eventTypeReferences, boolean isInsertInto, MatchEventSpec tags, Deque<Integer> subexpressionIdStack) throws ExprValidationException { int counter = 0; for (EvalNode child : evalNode.getChildNodes()) { subexpressionIdStack.addLast(counter++); recursiveCompile( child, context, eventTypeReferences, isInsertInto, tags, subexpressionIdStack); subexpressionIdStack.removeLast(); } LinkedHashMap<String, Pair<EventType, String>> newTaggedEventTypes = null; LinkedHashMap<String, Pair<EventType, String>> newArrayEventTypes = null; if (evalNode instanceof EvalFilterNode) { EvalFilterNode filterNode = (EvalFilterNode) evalNode; String eventName = filterNode.getRawFilterSpec().getEventTypeName(); EventType resolvedEventType = FilterStreamSpecRaw.resolveType( context.getEngineURI(), eventName, context.getEventAdapterService(), context.getPlugInTypeResolutionURIs()); EventType finalEventType = resolvedEventType; String optionalTag = filterNode.getEventAsName(); boolean isPropertyEvaluation = false; // obtain property event type, if final event type is properties if (filterNode.getRawFilterSpec().getOptionalPropertyEvalSpec() != null) { PropertyEvaluator optionalPropertyEvaluator = PropertyEvaluatorFactory.makeEvaluator( filterNode.getRawFilterSpec().getOptionalPropertyEvalSpec(), resolvedEventType, filterNode.getEventAsName(), context.getEventAdapterService(), context.getMethodResolutionService(), context.getSchedulingService(), context.getVariableService(), context.getEngineURI(), context.getStatementId(), context.getStatementName(), context.getAnnotations(), subexpressionIdStack); finalEventType = optionalPropertyEvaluator.getFragmentEventType(); isPropertyEvaluation = true; } if (finalEventType instanceof EventTypeSPI) { eventTypeReferences.add(((EventTypeSPI) finalEventType).getMetadata().getPrimaryName()); } // If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> // b=BeanA -> a=BeanB is a no if (optionalTag != null) { Pair<EventType, String> pair = tags.getTaggedEventTypes().get(optionalTag); EventType existingType = null; if (pair != null) { existingType = pair.getFirst(); } if (existingType == null) { pair = tags.getArrayEventTypes().get(optionalTag); if (pair != null) { throw new ExprValidationException( "Tag '" + optionalTag + "' for event '" + eventName + "' used in the repeat-until operator cannot also appear in other filter expressions"); } } if ((existingType != null) && (existingType != finalEventType)) { throw new ExprValidationException( "Tag '" + optionalTag + "' for event '" + eventName + "' has already been declared for events of type " + existingType.getUnderlyingType().getName()); } pair = new Pair<EventType, String>(finalEventType, eventName); // add tagged type if (isPropertyEvaluation) { newArrayEventTypes = new LinkedHashMap<String, Pair<EventType, String>>(); newArrayEventTypes.put(optionalTag, pair); } else { newTaggedEventTypes = new LinkedHashMap<String, Pair<EventType, String>>(); newTaggedEventTypes.put(optionalTag, pair); } } // For this filter, filter types are all known tags at this time, // and additionally stream 0 (self) is our event type. // Stream type service allows resolution by property name event if that name appears in other // tags. // by defaulting to stream zero. // Stream zero is always the current event type, all others follow the order of the map // (stream 1 to N). String selfStreamName = optionalTag; if (selfStreamName == null) { selfStreamName = "s_" + UuidGenerator.generate(); } LinkedHashMap<String, Pair<EventType, String>> filterTypes = new LinkedHashMap<String, Pair<EventType, String>>(); Pair<EventType, String> typePair = new Pair<EventType, String>(finalEventType, eventName); filterTypes.put(selfStreamName, typePair); filterTypes.putAll(tags.getTaggedEventTypes()); // for the filter, specify all tags used LinkedHashMap<String, Pair<EventType, String>> filterTaggedEventTypes = new LinkedHashMap<String, Pair<EventType, String>>(tags.getTaggedEventTypes()); filterTaggedEventTypes.remove(optionalTag); // handle array tags (match-until clause) LinkedHashMap<String, Pair<EventType, String>> arrayCompositeEventTypes = null; if (tags.getArrayEventTypes() != null) { arrayCompositeEventTypes = new LinkedHashMap<String, Pair<EventType, String>>(); String patternSubexEventType = getPatternSubexEventType(context.getStatementId(), "pattern", subexpressionIdStack); EventType arrayTagCompositeEventType = context .getEventAdapterService() .createSemiAnonymousMapType( patternSubexEventType, new HashMap(), tags.getArrayEventTypes(), isInsertInto); for (Map.Entry<String, Pair<EventType, String>> entry : tags.getArrayEventTypes().entrySet()) { String tag = entry.getKey(); if (!filterTypes.containsKey(tag)) { Pair<EventType, String> pair = new Pair<EventType, String>(arrayTagCompositeEventType, tag); filterTypes.put(tag, pair); arrayCompositeEventTypes.put(tag, pair); } } } StreamTypeService streamTypeService = new StreamTypeServiceImpl(filterTypes, context.getEngineURI(), true, false); List<ExprNode> exprNodes = filterNode.getRawFilterSpec().getFilterExpressions(); FilterSpecCompiled spec = FilterSpecCompiler.makeFilterSpec( resolvedEventType, eventName, exprNodes, filterNode.getRawFilterSpec().getOptionalPropertyEvalSpec(), filterTaggedEventTypes, arrayCompositeEventTypes, streamTypeService, context.getMethodResolutionService(), context.getSchedulingService(), context.getVariableService(), context.getEventAdapterService(), context.getEngineURI(), null, context, subexpressionIdStack); filterNode.setFilterSpec(spec); } else if (evalNode instanceof EvalObserverNode) { EvalObserverNode observerNode = (EvalObserverNode) evalNode; try { ObserverFactory observerFactory = context.getPatternResolutionService().create(observerNode.getPatternObserverSpec()); StreamTypeService streamTypeService = getStreamTypeService( context.getEngineURI(), context.getStatementId(), context.getEventAdapterService(), tags.taggedEventTypes, tags.arrayEventTypes, subexpressionIdStack, "observer"); ExprValidationContext validationContext = new ExprValidationContext( streamTypeService, context.getMethodResolutionService(), null, context.getSchedulingService(), context.getVariableService(), context, context.getEventAdapterService(), context.getStatementName(), context.getStatementId(), context.getAnnotations()); List<ExprNode> validated = validateExpressions( observerNode.getPatternObserverSpec().getObjectParameters(), validationContext); MatchedEventConvertor convertor = new MatchedEventConvertorImpl( tags.taggedEventTypes, tags.arrayEventTypes, context.getEventAdapterService()); observerNode.setObserverFactory(observerFactory); observerFactory.setObserverParameters(validated, convertor); } catch (ObserverParameterException e) { throw new ExprValidationException( "Invalid parameter for pattern observer: " + e.getMessage(), e); } catch (PatternObjectException e) { throw new ExprValidationException( "Failed to resolve pattern observer: " + e.getMessage(), e); } } else if (evalNode instanceof EvalGuardNode) { EvalGuardNode guardNode = (EvalGuardNode) evalNode; try { GuardFactory guardFactory = context.getPatternResolutionService().create(guardNode.getPatternGuardSpec()); StreamTypeService streamTypeService = getStreamTypeService( context.getEngineURI(), context.getStatementId(), context.getEventAdapterService(), tags.taggedEventTypes, tags.arrayEventTypes, subexpressionIdStack, "guard"); ExprValidationContext validationContext = new ExprValidationContext( streamTypeService, context.getMethodResolutionService(), null, context.getSchedulingService(), context.getVariableService(), context, context.getEventAdapterService(), context.getStatementName(), context.getStatementId(), context.getAnnotations()); List<ExprNode> validated = validateExpressions( guardNode.getPatternGuardSpec().getObjectParameters(), validationContext); MatchedEventConvertor convertor = new MatchedEventConvertorImpl( tags.taggedEventTypes, tags.arrayEventTypes, context.getEventAdapterService()); guardNode.setGuardFactory(guardFactory); guardFactory.setGuardParameters(validated, convertor); } catch (GuardParameterException e) { throw new ExprValidationException( "Invalid parameter for pattern guard: " + e.getMessage(), e); } catch (PatternObjectException e) { throw new ExprValidationException("Failed to resolve pattern guard: " + e.getMessage(), e); } } else if (evalNode instanceof EvalEveryDistinctNode) { EvalEveryDistinctNode distinctNode = (EvalEveryDistinctNode) evalNode; MatchEventSpec matchEventFromChildNodes = analyzeMatchEvent(distinctNode); StreamTypeService streamTypeService = getStreamTypeService( context.getEngineURI(), context.getStatementId(), context.getEventAdapterService(), matchEventFromChildNodes.getTaggedEventTypes(), matchEventFromChildNodes.getArrayEventTypes(), subexpressionIdStack, "every-distinct"); ExprValidationContext validationContext = new ExprValidationContext( streamTypeService, context.getMethodResolutionService(), null, context.getSchedulingService(), context.getVariableService(), context, context.getEventAdapterService(), context.getStatementName(), context.getStatementId(), context.getAnnotations()); List<ExprNode> validated; try { validated = validateExpressions(distinctNode.getExpressions(), validationContext); } catch (ExprValidationPropertyException ex) { throw new ExprValidationPropertyException( ex.getMessage() + ", every-distinct requires that all properties resolve from sub-expressions to the every-distinct", ex.getCause()); } MatchedEventConvertor convertor = new MatchedEventConvertorImpl( matchEventFromChildNodes.getTaggedEventTypes(), matchEventFromChildNodes.getArrayEventTypes(), context.getEventAdapterService()); distinctNode.setConvertor(convertor); // Determine whether some expressions are constants or time period List<ExprNode> distinctExpressions = new ArrayList<ExprNode>(); Long msecToExpire = null; for (ExprNode expr : validated) { if (expr instanceof ExprTimePeriod) { Double secondsExpire = (Double) ((ExprTimePeriod) expr).evaluate(null, true, context); if ((secondsExpire != null) && (secondsExpire > 0)) { msecToExpire = Math.round(1000d * secondsExpire); } log.debug("Setting every-distinct msec-to-expire to " + msecToExpire); } else if (expr.isConstantResult()) { log.warn( "Every-distinct node utilizes an expression returning a constant value, please check expression '" + expr.toExpressionString() + "', not adding expression to distinct-value expression list"); } else { distinctExpressions.add(expr); } } if (distinctExpressions.isEmpty()) { throw new ExprValidationException( "Every-distinct node requires one or more distinct-value expressions that each return non-constant result values"); } distinctNode.setExpressions(distinctExpressions, msecToExpire); } else if (evalNode instanceof EvalMatchUntilNode) { EvalMatchUntilNode matchUntilNode = (EvalMatchUntilNode) evalNode; // compile bounds expressions, if any MatchEventSpec untilMatchEventSpec = new MatchEventSpec(tags.getTaggedEventTypes(), tags.getArrayEventTypes()); StreamTypeService streamTypeService = getStreamTypeService( context.getEngineURI(), context.getStatementId(), context.getEventAdapterService(), untilMatchEventSpec.getTaggedEventTypes(), untilMatchEventSpec.getArrayEventTypes(), subexpressionIdStack, "until"); ExprValidationContext validationContext = new ExprValidationContext( streamTypeService, context.getMethodResolutionService(), null, context.getSchedulingService(), context.getVariableService(), context, context.getEventAdapterService(), context.getStatementName(), context.getStatementId(), context.getAnnotations()); String message = "Match-until bounds value expressions must return a numeric value"; if (matchUntilNode.getLowerBounds() != null) { ExprNode validated = ExprNodeUtility.getValidatedSubtree(matchUntilNode.getLowerBounds(), validationContext); matchUntilNode.setLowerBounds(validated); if ((validated.getExprEvaluator().getType() == null) || (!JavaClassHelper.isNumeric(validated.getExprEvaluator().getType()))) { throw new ExprValidationException(message); } } if (matchUntilNode.getUpperBounds() != null) { ExprNode validated = ExprNodeUtility.getValidatedSubtree(matchUntilNode.getUpperBounds(), validationContext); matchUntilNode.setUpperBounds(validated); if ((validated.getExprEvaluator().getType() == null) || (!JavaClassHelper.isNumeric(validated.getExprEvaluator().getType()))) { throw new ExprValidationException(message); } } MatchedEventConvertor convertor = new MatchedEventConvertorImpl( untilMatchEventSpec.getTaggedEventTypes(), untilMatchEventSpec.getArrayEventTypes(), context.getEventAdapterService()); matchUntilNode.setConvertor(convertor); // compile new tag lists Set<String> arrayTags = null; EvalNodeAnalysisResult matchUntilAnalysisResult = EvalNodeUtil.recursiveAnalyzeChildNodes(matchUntilNode.getChildNodes().get(0)); for (EvalFilterNode filterNode : matchUntilAnalysisResult.getFilterNodes()) { String optionalTag = filterNode.getEventAsName(); if (optionalTag != null) { if (arrayTags == null) { arrayTags = new HashSet<String>(); } arrayTags.add(optionalTag); } } if (arrayTags != null) { for (String arrayTag : arrayTags) { if (!tags.arrayEventTypes.containsKey(arrayTag)) { tags.arrayEventTypes.put(arrayTag, tags.taggedEventTypes.get(arrayTag)); tags.taggedEventTypes.remove(arrayTag); } } } matchUntilNode.setTagsArrayedSet(arrayTags); } else if (evalNode instanceof EvalFollowedByNode) { EvalFollowedByNode followedByNode = (EvalFollowedByNode) evalNode; StreamTypeService streamTypeService = new StreamTypeServiceImpl(context.getEngineURI(), false); ExprValidationContext validationContext = new ExprValidationContext( streamTypeService, context.getMethodResolutionService(), null, context.getSchedulingService(), context.getVariableService(), context, context.getEventAdapterService(), context.getStatementName(), context.getStatementId(), context.getAnnotations()); if (followedByNode.getOptionalMaxExpressions() != null) { List<ExprNode> validated = new ArrayList<ExprNode>(); for (ExprNode maxExpr : followedByNode.getOptionalMaxExpressions()) { if (maxExpr == null) { validated.add(null); } else { ExprNodeSummaryVisitor visitor = new ExprNodeSummaryVisitor(); maxExpr.accept(visitor); if (!visitor.isPlain()) { String errorMessage = "Invalid maximum expression in followed-by, " + visitor.getMessage() + " are not allowed within the expression"; log.error(errorMessage); throw new ExprValidationException(errorMessage); } ExprNode validatedExpr = ExprNodeUtility.getValidatedSubtree(maxExpr, validationContext); validated.add(validatedExpr); if ((validatedExpr.getExprEvaluator().getType() == null) || (!JavaClassHelper.isNumeric(validatedExpr.getExprEvaluator().getType()))) { String message = "Invalid maximum expression in followed-by, the expression must return an integer value"; throw new ExprValidationException(message); } } } followedByNode.setOptionalMaxExpressions(validated); } } if (newTaggedEventTypes != null) { tags.getTaggedEventTypes().putAll(newTaggedEventTypes); } if (newArrayEventTypes != null) { tags.getArrayEventTypes().putAll(newArrayEventTypes); } }
// {{{ trimToLimit() method private static void trimToLimit(Deque<Entry> list) { int max = jEdit.getIntegerProperty("recentFiles", 50); while (list.size() > max) list.removeLast(); } // }}}
@Override public void remove() { removeLast(); }
@Test(expected = NoSuchElementException.class) public void Deque_removeLast_throwsIfEmpty() { deque.removeLast(); }
@Test(expected = java.util.NoSuchElementException.class) public void testNoSuchElementExceptionWhenRemoveLastEmpty() { deque.removeLast(); }
void pushToPlayStack(Playlist p, Track t) { if (playStack.size() > 10000) { playStack.removeLast(); } playStack.push(new PlaylistAndTrack(p, t)); }