Java Deque.addLast方法代码示例

import java.util.Deque; //导入方法依赖的package包/类
static void dequeStuff() {
  Deque<Object> d = new ArrayDeque<>();
  // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required
  d.add(null);
  // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required
  d.addFirst(null);
  // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required
  d.addLast(null);
  // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required
  d.offerFirst(null);
  // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required
  d.offerLast(null);
  // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required
  d.offer(null);
  // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required
  d.push(null);
  // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required
  d.toArray(null);
}
 

import java.util.Deque; //导入方法依赖的package包/类
/**
 * Performs a BFS from a given starting pixel in order to determine the
 * border of the image.
 *
 * @param x the x coordinate of the starting point.
 * @param y the y coordinate of the starting point.
 */
private void bfsHelper(int x, int y) {
  Deque<Point<Integer>> queue = new ArrayDeque<>();
  queue.push(new Point<>(x, y));

  while (!queue.isEmpty()) {
    Point<Integer> popped = queue.pollLast();
    borderPoints.add(popped);

    for (int i = -1; i <= 1; i++) {
      for (int j = -1; j <= 1; j++) {
        Point<Integer> next = new Point<>(popped.getX() + i, popped.getY() + j);

        if (picture.contains(next) &&
            borderColor.sameColor(picture.getPixel(next.getX(), next.getY()),
                BLACK_SENSITIVITY) && !visited[next.getX()][next.getY()]) {
            visited[next.getX()][next.getY()] = true;
            queue.addLast(next);
        }
      }
    }
  }
}
 

import java.util.Deque; //导入方法依赖的package包/类
private void visitDepthFirst(AST ast) {
	if ( ast == null ) {
		return;
	}
	Deque<AST> stack = new ArrayDeque<AST>();
	stack.addLast( ast );
	while ( !stack.isEmpty() ) {
		ast = stack.removeLast();
		strategy.visit( ast );
		if ( ast.getNextSibling() != null ) {
			stack.addLast( ast.getNextSibling() );
		}
		if ( ast.getFirstChild() != null ) {
			stack.addLast( ast.getFirstChild() );
		}
	}
}
 

import java.util.Deque; //导入方法依赖的package包/类
private void createLoads(DefUseTree tree, ConstantTree constTree, AbstractBlockBase<?> startBlock) {
    Deque<AbstractBlockBase<?>> worklist = new ArrayDeque<>();
    worklist.add(startBlock);
    while (!worklist.isEmpty()) {
        AbstractBlockBase<?> block = worklist.pollLast();
        if (constTree.get(Flags.CANDIDATE, block)) {
            constTree.set(Flags.MATERIALIZE, block);
            // create and insert load
            insertLoad(tree.getConstant(), tree.getVariable().getValueKind(), block, constTree.getCost(block).getUsages());
        } else {
            AbstractBlockBase<?> dominated = block.getFirstDominated();
            while (dominated != null) {
                if (constTree.isMarked(dominated)) {
                    worklist.addLast(dominated);
                }
                dominated = dominated.getDominatedSibling();
            }
        }
    }
}
 

import java.util.Deque; //导入方法依赖的package包/类
@Test
public void testAddLastOrigin() {
    Deque<Integer> queue = new ArrayDeque<Integer>();
    queue.addLast(1);
    queue.addLast(2);
    queue.addLast(3);

    assertThat(queue).containsExactly(1, 2, 3);
}
 

import java.util.Deque; //导入方法依赖的package包/类
public Deque<DistanceFrom> generatePath() {

        List<FutureTask<DistanceFrom>> effectiveDistanceFromStart = calculateDistanceFromStart(
                initialPosition,
                getInRange(
                        initialPosition,
                        MIN_DISTANCE_FIRST_HOP,
                        MAX_DISTANCE_FIRST_HOP
                ));
        Collections.shuffle(effectiveDistanceFromStart); // Randomizing the points...

        for (FutureTask<DistanceFrom> distanceFromFutureTask : effectiveDistanceFromStart) {
            Deque<DistanceFrom> path = new ArrayDeque<>();
            try {
                DistanceFrom distance = distanceFromFutureTask.get();
                Map<LatLng, Boolean> visitedTable = new HashMap<>();

                visitedTable.put(distance.end, true);

                path.addLast(distance);
                path.addAll(pathChooser(distance,
                        maxDistance - (distance.distance/1000),
                        visitedTable,
                        5));
                if (path.size() >= HOP_MIN_NUM) {
                    return path;
                }
            } catch (InterruptedException | ExecutionException  e) {
                e.printStackTrace();
            }
        }
        return new ArrayDeque<>();
    }
 

import java.util.Deque; //导入方法依赖的package包/类
public void printFromTopToBottom(TreeNode root) {
    if (root == null) return;
    Deque<TreeNode> queue = new ArrayDeque<>();
    queue.addLast(root);

    while (!queue.isEmpty()) {
        TreeNode node = queue.pop();
        System.out.print(node.val + " ");
        if (node.left != null)
            queue.addLast(node.left);
        if (node.right != null)
            queue.addLast(node.right);
    }
}
 

import java.util.Deque; //导入方法依赖的package包/类
void refreshMeter() {
    BaseComponent label;
    ChatColor color = METER_COLORS.get(stamina);

    if(color != null) {
        int segments = METER_COLORS.asMapOfRanges().size();
        Deque<BaseComponent> parts = new ArrayDeque<>(segments * 2 + 3);

        parts.add(SPACE);
        parts.add(new TranslatableComponent("stamina.label"));
        parts.add(SPACE);

        for(Map.Entry<Range<Double>, ChatColor> entry : METER_COLORS.asMapOfRanges().entrySet()) {
            int length = (int) (METER_SCALE * (Numbers.clamp(stamina, entry.getKey()) - entry.getKey().lowerEndpoint()));
            Component segment = new Component(Strings.repeat("\u23d0", length), entry.getValue());
            parts.addFirst(segment);
            parts.addLast(segment);
        }

        label = new Component(color).extra(parts);
    } else {
        StaminaMutator cause = getDepletionCause();
        if(cause != null) {
            label = new Component(new TranslatableComponent("stamina.depletedFromMutator",
                                                            new Component(cause.getDescription(), ChatColor.AQUA)),
                                  ChatColor.RED);
        } else {
            label = new Component(new TranslatableComponent("stamina.depleted"), ChatColor.RED);
        }
    }

    player.sendHotbarMessage(label);
}
 

import java.util.Deque; //导入方法依赖的package包/类
public void print(TreeNode root) {
	
	if (root == null)
		return;
	
	Deque<TreeNode> queue = new ArrayDeque<>();
	queue.addLast(root);
	int nextLevel = 0;
	int toBePrinted = 1;
	while (!queue.isEmpty()) {
		TreeNode node = queue.getFirst();
		System.out.print(node.val + " ");
		if (node.left != null) {
			queue.addLast(node.left);
			++nextLevel;
		}
		if (node.right != null) {
			queue.addLast(node.right);
			++nextLevel;
		}
		
		queue.pop();
		--toBePrinted;
		if (toBePrinted == 0) {
			System.out.println();
			toBePrinted = nextLevel;
			nextLevel = 0;
		}
	}
}
 

import java.util.Deque; //导入方法依赖的package包/类
/**
 * Returns all array indices for the given expression, e.g. given {@code foo[0][0]} returns the
 * expressions for {@code [0][0]}.
 */
private Deque<ExpressionTree> getArrayIndices(ExpressionTree expression) {
    Deque<ExpressionTree> indices = new ArrayDeque<>();
    while (expression instanceof ArrayAccessTree) {
        ArrayAccessTree array = (ArrayAccessTree) expression;
        indices.addLast(array.getIndex());
        expression = array.getExpression();
    }
    return indices;
}
 

import java.util.Deque; //导入方法依赖的package包/类
public static Context with(Iterable<PathElement> ancestors) {
	Deque<PathElement> ancestorsStack = getAncestors();
	int count = 0;
	for (PathElement ancestor : ancestors) {
		ancestorsStack.addLast(ancestor);
		count++;
	}
	return new Context(count);
}
 

import java.util.Deque; //导入方法依赖的package包/类
public<M extends IPredicateMap<P,T,State,M>> DFA(M factory, FSA<T,F,P> automaton, boolean debug) {
    this(factory);
    // Перезапускаем автомат и сохраняем стартовое состояние
    Set<State> old_initial=automaton.initialState();
    // Создаем отображение старых состояний на новые
    Map<Set<State>,State> old2new=new HashMap();
    State new_initial=debug?this.newState(old_initial,automaton):this.newState();
    old2new.put(old_initial,new_initial);
    // Создаем массив состояний, которые мы еще не рассмотрели
    Deque<Set<State>> unprocessed=new ArrayDeque();
    unprocessed.addLast(old_initial);        
    // Перебираем все состояния 
    Set<State> old_states;
    while((old_states=unprocessed.poll())!=null) {
        State active=old2new.get(old_states);
        // и делаем из состояния active все переходы.
        // Получаем все возможные символы для перехода.
        Map<P,Set<State>> old_transitions=DFA.purifyTransitions(automaton.getTransitions(old_states));
        // Маркируем остановочные состояния
        for(F mark: automaton.getMarkers(old_states))
            this.markState(active, mark);
        // Для каждого символа перехода
        for(Map.Entry<P,Set<State>> entry: old_transitions.entrySet()) {
            // Ищем куда ведет переход
            Set<State> old_targets=entry.getValue();
            automaton.doEpsilonTransition(old_targets);
            State target;
            if(old2new.containsKey(old_targets)) target=old2new.get(old_targets);
            else {
                target=debug?this.newState(old_targets,automaton):this.newState();
                old2new.put(old_targets,target);
                // Если состояние новое, то добавляем его в список непроанализированных состояний
                unprocessed.addLast(old_targets);
            };
            // Создаем переход в новом автомате
            this.newTransition(active,target,entry.getKey());
        };
    };
}
 

import java.util.Deque; //导入方法依赖的package包/类
@Override
public void release(ByteBuffer buffer) {
    buffer.clear();
    Deque<ByteBuffer> bufferQueue = bufferMap.get(buffer.capacity());
    if (bufferQueue == null) {
        // We currently keep a single buffer in flight, so optimise for that case
        bufferQueue = new ArrayDeque<>(1);
        bufferMap.put(buffer.capacity(), bufferQueue);
    }
    bufferQueue.addLast(buffer);
}
 

import java.util.Deque; //导入方法依赖的package包/类
@Test
public void testInvokePush() throws ScriptException {
    final Deque<Object> l = getListAdapter();
    l.addLast(5);
    assertEquals(l.size(), 5);
    assertEquals(l.getLast(), 5);
    assertEquals(l.getFirst(), 1);
}
 

import java.util.Deque; //导入方法依赖的package包/类
/**
 * Adds all interfaces from this class to the deque of interfaces.
 *
 * @param intfs the deque of interfaces
 * @param cf the ClassFile of this class
 * @throws ConstantPoolException if a constant pool entry cannot be found
 */
void addInterfaces(Deque<String> intfs, ClassFile cf)
        throws ConstantPoolException {
    int count = cf.interfaces.length;
    for (int i = 0; i < count; i++) {
        intfs.addLast(cf.getInterfaceName(i));
    }
}