下面列出了java.util.AbstractSet#java.util.ArrayDeque 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public void writeStartElement(final String localName) throws XMLStreamException {
ArrayDeque<String> namespaces = unspecifiedNamespaces;
String namespace = namespaces.getFirst();
if (namespace != NO_NAMESPACE) {
writeStartElement(namespace, localName);
return;
}
unspecifiedNamespaces.push(namespace);
// If this is a nested element flush the outer
nl();
indent();
delegate.writeStartElement(localName);
level++;
state = START_ELEMENT;
indentEndElement = false;
}
public SyncEngine(
LocalStore localStore,
RemoteStore remoteStore,
User initialUser,
int maxConcurrentLimboResolutions) {
this.localStore = localStore;
this.remoteStore = remoteStore;
this.maxConcurrentLimboResolutions = maxConcurrentLimboResolutions;
queryViewsByQuery = new HashMap<>();
queriesByTarget = new HashMap<>();
enqueuedLimboResolutions = new ArrayDeque<>();
activeLimboTargetsByKey = new HashMap<>();
activeLimboResolutionsByTarget = new HashMap<>();
limboDocumentRefs = new ReferenceSet();
mutationUserCallbacks = new HashMap<>();
targetIdGenerator = TargetIdGenerator.forSyncEngine();
currentUser = initialUser;
pendingWritesCallbacks = new HashMap<>();
}
private void binary_SPACE(Metadata metadata, ArrayDeque<Metadata> parents) {
final Optional<Metadata> pmd = parents.stream().skip(1).findFirst();
final Operator pmdOperator = pmd.map(Metadata::getOperator).orElse(null);
final boolean leftChild = pmd.map(m -> m.childAt(0) == metadata).orElse(false);
if ((!leftChild || pmdOperator != or || metadata.getOperator() != and)) {
// @see io.doov.core.dsl.meta.ast.HtmlAndTest.and_or_and()
writer.writeExclusionBar(metadata, parents);
}
toHtml(metadata.childAt(0), parents);
writer.write(SPACE);
writer.writeBeginSpan(CSS_OPERATOR);
writer.writeFromBundle(metadata.getOperator());
writer.writeEndSpan();
writer.write(SPACE);
toHtml(metadata.childAt(1), parents);
}
/**
* 双端队列
*
* @param nums
* @param k
* @return
*/
public int[] maxSlidingWindow(int[] nums, int k) {
int len = nums.length;
if (len == 0) {
return new int[0];
}
int[] res = new int[len - k + 1];
Deque<Integer> queue = new ArrayDeque<>();
for (int i = 0; i < len; i++) {
if (i >= k && queue.getFirst() == i - k) {
queue.removeFirst();
}
while (!queue.isEmpty() && nums[queue.getLast()] <= nums[i]) {
queue.removeLast();
}
queue.add(i);
if (i >= k - 1) {
res[i - k + 1] = nums[queue.getFirst()];
}
}
return res;
}
private static Collection<Type> listSupertypes(Type... types) {
Set<Type> supertypes = new HashSet<>();
Deque<Type> next = new ArrayDeque<>();
Collections.addAll(next, types);
while (!next.isEmpty()) {
Type type = next.remove();
for (Type sType : Type.BY_NAME.values()) {
if (sType.subTypes.contains(type) && supertypes.add(sType)) {
next.add(sType);
}
}
}
return supertypes;
}
private static @Nullable SchemaNode findTargetNode(final SchemaContext context, final QNameModule localNamespace,
final YangLocationPath path) {
final Deque<QName> ret = new ArrayDeque<>();
for (Step step : path.getSteps()) {
if (step instanceof AxisStep) {
// We only support parent axis steps
final YangXPathAxis axis = ((AxisStep) step).getAxis();
checkState(axis == YangXPathAxis.PARENT, "Unexpected axis %s", axis);
ret.removeLast();
continue;
}
// This has to be a QNameStep
checkState(step instanceof QNameStep, "Unhandled step %s in %s", step, path);
ret.addLast(resolve(((QNameStep) step).getQName(), localNamespace));
}
return findTargetNode(context, ret);
}
public static LPRoutedItem readFromNBT(NBTTagCompound compound, TileGenericPipe holder) {
double x = compound.getDouble("posX");
double y = compound.getDouble("posY");
double z = compound.getDouble("posZ");
UUID id = compound.getUniqueId("UID");
ItemStack content = new ItemStack(compound.getCompoundTag("inventory"));
int ticks = compound.getInteger("ticks");
Deque<EnumFacing> routingInfo = new ArrayDeque<>();
NBTTagList routeList = (NBTTagList) compound.getTag("route");
for(Iterator<NBTBase> i = routeList.iterator(); i.hasNext();) {
NBTTagCompound node = (NBTTagCompound) i.next();
EnumFacing nodeTuple = EnumFacing.values()[node.getInteger("heading")];
routingInfo.add(nodeTuple);
}
LPRoutedItem item = new LPRoutedItem(x, y, z, content, ticks, id);
item.setHeading(EnumFacing.VALUES[compound.getInteger("heading")]);
item.setHolding(holder);
item.route = routingInfo;
return item;
}
private void assignClusterId() {
Queue<TreeNode> queue = new ArrayDeque<>();
queue.add(root);
long id = 0L;
treeNodeIds = new ArrayList<>();
while (!queue.isEmpty()) {
TreeNode top = queue.poll();
if (top.isLeaf()) {
top.clusterId = id;
treeNodeIds.add(top.treeNodeId);
id++;
} else {
if (top.leftChild != null) {
queue.add(top.leftChild);
}
if (top.rightChild != null) {
queue.add(top.rightChild);
}
}
}
}
/**
* Test NegativeAcknowledger bulk action with a large batch
*/
@Test
public void testNackBulkActionLargeBatch() throws JMSException {
/*
* Set up the message queue
*/
ArrayDeque<SQSMessageConsumerPrefetch.MessageManager> messageQueue = addSQSMessageToQueue(13);
/*
* Nack the messages in bulk actions
*/
negativeAcknowledger.bulkAction(messageQueue, QUEUE_URL);
/*
* Verify results
*/
verify(negativeAcknowledger, times(2)).action(eq(QUEUE_URL), anyList());
}
public void send(String address, List<Message> messages, long timeout, TimeUnit timeUnit) throws InterruptedException {
ProtonClient client = ProtonClient.create(vertx);
CountDownLatch latch = new CountDownLatch(1);
Queue<Message> messageQueue = new ArrayDeque<>(messages);
client.connect(host, port, connectEvent -> {
if (connectEvent.succeeded()) {
ProtonConnection connection = connectEvent.result();
connection.open();
ProtonSender sender = connection.createSender(address);
sender.openHandler(senderOpenEvent -> {
if (senderOpenEvent.succeeded()) {
sendNext(connection, sender, messageQueue, latch);
}
});
sender.open();
}
});
boolean ok = latch.await(timeout, timeUnit);
if (!ok) {
throw new RuntimeException("Sending messages timed out, " + messageQueue.size() + " messages unsent");
}
}
public QueryObjectProvider(DatabaseSession databaseSession, BimServer bimServer, Query query, Set<Long> roids, PackageMetaData packageMetaData) throws IOException, QueryException {
this.databaseSession = databaseSession;
this.bimServer = bimServer;
this.query = query;
this.roids = roids;
this.packageMetaData = packageMetaData;
stack = new ArrayDeque<StackFrame>();
stack.push(new StartFrame(this, roids));
for (QueryPart queryPart : query.getQueryParts()) {
if (queryPart.hasOids()) {
goingToRead.addAll(queryPart.getOids());
}
}
}
/**
* Tests that broadcasted events' buffers are independent (in their (reader) indices) once they
* are put into the queue for Netty when broadcasting events to multiple channels.
*/
@Test
public void testBroadcastEventBufferIndependence() throws Exception {
@SuppressWarnings("unchecked")
ArrayDeque<BufferConsumer>[] queues =
new ArrayDeque[]{new ArrayDeque(), new ArrayDeque()};
ResultPartitionWriter partition =
new CollectingPartitionWriter(queues, new TestPooledBufferProvider(Integer.MAX_VALUE));
RecordWriter<?> writer = new RecordWriter<>(partition);
writer.broadcastEvent(EndOfPartitionEvent.INSTANCE);
// Verify added to all queues
assertEquals(1, queues[0].size());
assertEquals(1, queues[1].size());
// these two buffers may share the memory but not the indices!
Buffer buffer1 = buildSingleBuffer(queues[0].remove());
Buffer buffer2 = buildSingleBuffer(queues[1].remove());
assertEquals(0, buffer1.getReaderIndex());
assertEquals(0, buffer2.getReaderIndex());
buffer1.setReaderIndex(1);
assertEquals("Buffer 2 shares the same reader index as buffer 1", 0, buffer2.getReaderIndex());
}
private static void propagateRemove(ArrayDeque<LightNode> removeQueue, ArrayDeque<LightNode> addQueue, LightWorldSection w) {
if (removeQueue.isEmpty()) return;
while (!removeQueue.isEmpty()) {
LightNode n = removeQueue.pop();
int x = n.x;
int y = n.y;
int z = n.z;
int l = n.l;
if (l <= 1) continue;
tryPropagateRemove(removeQueue, addQueue, w, x - 1, y, z, l);
tryPropagateRemove(removeQueue, addQueue, w, x + 1, y, z, l);
tryPropagateRemove(removeQueue, addQueue, w, x, y, z - 1, l);
tryPropagateRemove(removeQueue, addQueue, w, x, y, z + 1, l);
if (y > 0)
tryPropagateRemove(removeQueue, addQueue, w, x, y - 1, z, 16); //16 is higher than maximum light, therefore the sunlight is always removed
tryPropagateRemove(removeQueue, addQueue, w, x, y + 1, z, l);
}
}
/**
* Optimize operations with first is REMOVE operation and last is ADD
* operation.
*/
@Test
public void testOptimizeOperationsRToA() {
Deque<VplsOperation> operations = new ArrayDeque<>();
VplsData vplsData = VplsData.of(VPLS1);
vplsData.addInterfaces(ImmutableSet.of(V100H1));
VplsOperation vplsOperation = VplsOperation.of(vplsData,
VplsOperation.Operation.REMOVE);
operations.add(vplsOperation);
vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
vplsOperation = VplsOperation.of(vplsData,
VplsOperation.Operation.ADD);
operations.add(vplsOperation);
vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.UPDATE), vplsOperation);
}
public synchronized void clearTerminatedJobs() {
Iterator<Map.Entry<Long, UpstreamJob>> itr = workingJobs.entrySet().iterator();
while (itr.hasNext()) {
UpstreamJob job = itr.next().getValue();
if (job.isTerminated()) {
job.terminate();
itr.remove();
}
}
Queue<UpstreamJob> oldQueue = queue;
queue = new ArrayDeque<>();
oldQueue.forEach(job -> {
if (!job.isTerminated()) {
queue.add(job);
}
});
}
public static PartialSolution initialize(WeightedGraph graph) {
final Partition<Node> stronglyConnected = Partition.singletons(graph.getNodes());
final HashMap<Node, Weighted<DirectedEdge>> incomingByScc = new HashMap<>();
final Deque<ExclusiveEdge> exclusiveEdges = new ArrayDeque<>();
// group edges by their destination component
final EdgeQueueMap incomingEdges = new EdgeQueueMap(stronglyConnected);
for (Node destinationNode : graph.getNodes()) {
for (Weighted<DirectedEdge> inEdge : graph.getIncomingEdges(destinationNode)) {
if (inEdge.weight != Double.NEGATIVE_INFINITY) {
incomingEdges.addEdge(inEdge);
}
}
}
return new PartialSolution(
stronglyConnected,
Partition.singletons(graph.getNodes()),
incomingByScc,
exclusiveEdges,
incomingEdges,
0.0
);
}
/**
* Helper method for import declarations, names, and qualified names.
*/
private void visitName(Tree node) {
Deque<Name> stack = new ArrayDeque<>();
for (; node instanceof MemberSelectTree; node = ((MemberSelectTree) node).getExpression()) {
stack.addFirst(((MemberSelectTree) node).getIdentifier());
}
stack.addFirst(((IdentifierTree) node).getName());
boolean first = true;
for (Name name : stack) {
if (!first) {
token(".");
}
token(name.toString());
first = false;
}
}
/** Returns bitset marking states reachable from the initial state. */
private static BitSet getLiveStatesFromInitial(Automaton a) {
int numStates = a.getNumStates();
BitSet live = new BitSet(numStates);
if (numStates == 0) {
return live;
}
ArrayDeque<Integer> workList = new ArrayDeque<>();
live.set(0);
workList.add(0);
Transition t = new Transition();
while (workList.isEmpty() == false) {
int s = workList.removeFirst();
int count = a.initTransition(s, t);
for(int i=0;i<count;i++) {
a.getNextTransition(t);
if (live.get(t.dest) == false) {
live.set(t.dest);
workList.add(t.dest);
}
}
}
return live;
}
/**
* Stack.
* Iterate through the string characters.
* If it's a number, just push to stack.
* If it's a '#', we need to figure out some sub situations:
* 1) If the top of the stack is a number, then this '#' is the left child, just push it.
* 2) If the top of the stack is a '#', then this '#' is the right child, we should pop the subtree.
* 2.1) After the subtree is popped, if the stack top is still '#', it means the subtree should be popped again.
* 2.2) If the stack top is a number, we need to add a '#' to mark that the next node knows it's a right child.
* https://discuss.leetcode.com/topic/35973/java-intuitive-22ms-solution-with-stack
*/
public boolean isValidSerialization(String preorder) {
Deque<String> stack = new ArrayDeque<>();
String[] nodes = preorder.split(",");
for (int i = 0; i < nodes.length; i++) {
String curr = nodes[i];
while ("#".equals(curr) && !stack.isEmpty() && "#".equals(stack.peek())) {
stack.pop();
if (stack.isEmpty()) {
return false;
}
stack.pop();
}
stack.push(curr);
}
return stack.size() == 1 && "#".equals(stack.peek());
}
private <E extends Exception> void saveProjects(@NonNull final Class<E> clz) throws E {
final Queue<Exception> causes = new ArrayDeque<Exception>();
for (Project prj : projects) {
try {
owner.saveProject(prj);
} catch (IOException ioe) {
causes.add(ioe);
}
}
if (!causes.isEmpty()) {
try {
final E exc = clz.getDeclaredConstructor().newInstance();
for (Exception cause : causes) {
exc.addSuppressed(cause);
}
throw exc;
} catch (ReflectiveOperationException e) {
throw new IllegalStateException(e);
}
}
}
@Test
public void testReadFinishedInput() throws Exception {
try {
testInputSelection(new TestReadFinishedInputStreamOperatorFactory(), true, new ArrayDeque<>(), true);
fail("should throw an IOException");
} catch (Exception t) {
if (!ExceptionUtils.findThrowableWithMessage(t, "Can not make a progress: all selected inputs are already finished").isPresent()) {
throw t;
}
}
}
/**
* Creates a new writer for the given version of the standards.
*/
TransformingWriter(final XMLEventWriter out, final TransformVersion version) {
super(version);
this.out = out;
uniqueNamespaces = new LinkedHashMap<>();
deferred = new ArrayDeque<>();
}
/**
* @param flags Flags that control the extractor's behavior.
* @param timestampAdjuster Adjusts sample timestamps. May be null if no adjustment is needed.
* @param sideloadedTrack Sideloaded track information, in the case that the extractor will not
* receive a moov box in the input data. Null if a moov box is expected.
* @param sideloadedDrmInitData The {@link DrmInitData} to use for encrypted tracks. If null, the
* pssh boxes (if present) will be used.
* @param closedCaptionFormats For tracks that contain SEI messages, the formats of the closed
* caption channels to expose.
* @param additionalEmsgTrackOutput An extra track output that will receive all emsg messages
* targeting the player, even if {@link #FLAG_ENABLE_EMSG_TRACK} is not set. Null if special
* handling of emsg messages for players is not required.
*/
public FragmentedMp4Extractor(
@Flags int flags,
@Nullable TimestampAdjuster timestampAdjuster,
@Nullable Track sideloadedTrack,
@Nullable DrmInitData sideloadedDrmInitData,
List<Format> closedCaptionFormats,
@Nullable TrackOutput additionalEmsgTrackOutput) {
this.flags = flags | (sideloadedTrack != null ? FLAG_SIDELOADED : 0);
this.timestampAdjuster = timestampAdjuster;
this.sideloadedTrack = sideloadedTrack;
this.sideloadedDrmInitData = sideloadedDrmInitData;
this.closedCaptionFormats = Collections.unmodifiableList(closedCaptionFormats);
this.additionalEmsgTrackOutput = additionalEmsgTrackOutput;
eventMessageEncoder = new EventMessageEncoder();
atomHeader = new ParsableByteArray(Atom.LONG_HEADER_SIZE);
nalStartCode = new ParsableByteArray(NalUnitUtil.NAL_START_CODE);
nalPrefix = new ParsableByteArray(5);
nalBuffer = new ParsableByteArray();
scratchBytes = new byte[16];
scratch = new ParsableByteArray(scratchBytes);
containerAtoms = new ArrayDeque<>();
pendingMetadataSampleInfos = new ArrayDeque<>();
trackBundles = new SparseArray<>();
durationUs = C.TIME_UNSET;
pendingSeekTimeUs = C.TIME_UNSET;
segmentIndexEarliestPresentationTimeUs = C.TIME_UNSET;
enterReadingAtomHeaderState();
}
private Set<Resource> findReachableResources(List<Resource> roots) {
final Multimap<Resource, Resource> referenceLog = LinkedHashMultimap.create();
Deque<Resource> queue = new ArrayDeque<>(roots);
final Set<Resource> reachable = new LinkedHashSet<>();
while (!queue.isEmpty()) {
Resource resource = queue.pop();
if (resource.references != null) {
resource.references.forEach(
r -> {
referenceLog.put(r, resource);
// add if it has not been marked reachable, therefore processed.
if (!reachable.contains(r)) {
queue.add(r);
}
});
}
// if we see it, it is reachable.
reachable.add(resource);
}
// dump resource reference map:
final StringBuilder keptResourceLog = new StringBuilder();
referenceLog
.asMap()
.forEach(
(resource, referencesTo) ->
keptResourceLog
.append(printResource(resource))
.append(" => [")
.append(
referencesTo.stream()
.map(ProtoResourceUsageAnalyzer::printResource)
.collect(joining(", ")))
.append("]\n"));
logger.fine("Kept resource references:\n" + keptResourceLog);
return reachable;
}
private void addUnprocessedEvent(int partition, String topic, KafkaIncomingEvent event) {
if (isAutoCommitEnabled) {
return;
}
TopicPartition key = new TopicPartition(topic, partition);
Queue<KafkaIncomingEvent> queue = unprocessedEventQueues.get(key);
if (queue == null) {
queue = new SynchronizedQueue<>(new ArrayDeque<KafkaIncomingEvent>());
synchronized (unprocessedEventQueues) {
unprocessedEventQueues.put(key, queue);
}
}
queue.add(event);
}
HybridOffHeapMemoryPool(int numInitialSegments, int segmentSize) {
this.availableMemory = new ArrayDeque<>(numInitialSegments);
this.segmentSize = segmentSize;
for (int i = 0; i < numInitialSegments; i++) {
this.availableMemory.add(ByteBuffer.allocateDirect(segmentSize));
}
}
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(candidates);
int len = candidates.length;
dfs(candidates, target, 0, len, new ArrayDeque<>(len), res);
return res;
}
/**
* Calculates the destination file.
*
* @param resource the source file
* @return the destination file's parent directory
*/
private File getDestinationFile( File resource )
{
File parent = resource.getParentFile();
Deque<String> fileComponentStack = new ArrayDeque<>();
fileComponentStack.push( resource.getName() );
while ( parent != null )
{
if ( "schema".equals( parent.getName() ) )
{
// All LDIF files besides the schema.ldif are under the
// schema/schema base path. So we need to add one more
// schema component to all LDIF files minus this schema.ldif
fileComponentStack.push( "schema" );
return assembleDestinationFile( fileComponentStack );
}
fileComponentStack.push( parent.getName() );
if ( parent.equals( parent.getParentFile() ) || parent.getParentFile() == null )
{
throw new IllegalStateException( I18n.err( I18n.ERR_16004_ROOT_WITHOUT_SCHEMA ) );
}
parent = parent.getParentFile();
}
throw new IllegalStateException( I18n.err( I18n.ERR_16005_PARENT_NULL ) );
}
public static void main(String[] args) {
int[] nums = {0, 0, 0, 0};
Solution solution3 = new Solution();
List<List<Integer>> res = solution3.threeSum(nums);
res.forEach(System.out::println);
List<Integer> res1 = new ArrayList<>();
Deque<Integer> stack = new ArrayDeque<Integer>();
}
private synchronized void flatten(final boolean flattenNested) {
// We use iterative traversal as recursion may exceed the stack size limit.
final char[] chars = new char[length];
int pos = length;
// Strings are most often composed by appending to the end, which causes ConsStrings
// to be very unbalanced, with mostly single string elements on the right and a long
// linear list on the left. Traversing from right to left helps to keep the stack small
// in this scenario.
final Deque<CharSequence> stack = new ArrayDeque<>();
stack.addFirst(left);
CharSequence cs = right;
do {
if (cs instanceof ConsString) {
final ConsString cons = (ConsString) cs;
// Count the times a cons-string is traversed as part of other cons-strings being flattened.
// If it crosses a threshold we flatten the nested cons-string internally.
if (cons.state == STATE_FLATTENED || (flattenNested && ++cons.state >= STATE_THRESHOLD)) {
cs = cons.flattened(false);
} else {
stack.addFirst(cons.left);
cs = cons.right;
}
} else {
final String str = (String) cs;
pos -= str.length();
str.getChars(0, str.length(), chars, pos);
cs = stack.isEmpty() ? null : stack.pollFirst();
}
} while (cs != null);
left = new String(chars);
right = "";
state = STATE_FLATTENED;
}