Java Queue.size方法代码示例

import java.util.Queue; //导入方法依赖的package包/类
public List<Double> averageOfLevels(TreeNode node) {
    List<Double> list = new LinkedList<>();
    if (node == null) return list;
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(node);
    while (!q.isEmpty()) {
        int size = q.size();
        double sum = 0;
        int i = 0;
        while (i < size) {
            TreeNode t = q.poll();
            sum += t.val;
            if (t.left != null) q.offer(t.left);
            if (t.right != null) q.offer(t.right);
            i++;
        }
        list.add(sum / size);
    }
    return list;
}
 

import java.util.Queue; //导入方法依赖的package包/类
public List<Integer> rightSideView(TreeNode root) {
    if (root == null) return new LinkedList<>();
    Queue<TreeNode> q = new LinkedList<>();
    List<Integer> l = new LinkedList<>();
    q.offer(root);
    while (!q.isEmpty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            TreeNode t = q.poll();
            if (i == 0) l.add(t.val);
            if (t.right != null) {
                q.offer(t.right);
            }
            if (t.left != null) {
                q.offer(t.left);
            }
        }
    }
    return l;
}
 

import java.util.Queue; //导入方法依赖的package包/类
private void free(ByteBuffer oldBuf) {
    if ((oldBuf == null) || ((maxCachedBufferSize != 0) && (oldBuf.capacity() > maxCachedBufferSize))
            || oldBuf.isReadOnly() || isDerived() || (Thread.currentThread() != ownerThread)) {
        return;
    }

    // Add to the cache.
    Queue<CachedBuffer> pool;

    if (oldBuf.isDirect()) {
        pool = directBuffers.get().get(oldBuf.capacity());
    } else {
        pool = heapBuffers.get().get(oldBuf.capacity());
    }

    if (pool == null) {
        return;
    }

    // Restrict the size of the pool to prevent OOM.
    if ((maxPoolSize == 0) || (pool.size() < maxPoolSize)) {
        pool.offer(new CachedBuffer(oldBuf));
    }
}
 

import java.util.Queue; //导入方法依赖的package包/类
/**
 * 将字符串解析分离成emoji图片节点和文本节点
 * @param input 输入字符串
 * @return
 */
public static Node[] createEmojiAndTextNode(String input) {
	Queue<Object> queue = EmojiHandler.getInstance().toEmojiAndText(input);
	Node[] nodes = new Node[queue.size()];
	int i = 0;
	while (!queue.isEmpty()) {
		Object ob = queue.poll();
		if (ob instanceof String) {
			String text = (String) ob;
			nodes[i++] = createTextNode(text);
		} else if (ob instanceof Emoji) {
			Emoji emoji = (Emoji) ob;
			nodes[i++] = createEmojiNode(emoji, 24, 10);
		}
	}
	return nodes;
}
 

import java.util.Queue; //导入方法依赖的package包/类
public void add(final Stock stock){
    final Queue<OhlcContainer> sequence = this.sequences.get(stock.getCode());
    final OhlcContainer latest = sequence.peek();

    if ((latest == null) || (latest.getTime().isBefore(stock.getTime()) && latest.getClose() != stock.getClose())) {
        getLogger().debug("New {} stock {} passed for average processing", stock.getCode(), stock);
        if (sequence.size() == 10)
            sequence.remove();

        sequence.add(stock);

        this.values.replace(stock.getCode(), sequence.stream()
                .mapToDouble(OhlcContainer::getClose)
                .sum() / 10);
    }
}
 

import java.util.Queue; //导入方法依赖的package包/类
@Override
public int size() {
    int total = 0;
    for (final Queue queue: messageBuffer.values()) {
        total += queue.size();
    }
    return total;
}
 

import java.util.Queue; //导入方法依赖的package包/类
public static Node search(Node root, int taskId) {
  Queue<Node> queue = new LinkedList<>();
  queue.add(root);

  while (queue.size() > 0) {
    Node current = queue.poll();
    if (taskId >= 0 && current.getTaskId() == taskId) {
      return current;
    } else {
      queue.addAll(current.getChildren());
    }
  }

  return null;
}
 

import java.util.Queue; //导入方法依赖的package包/类
/**
 * Return the number of available buffers of a given size.
 * This is used only for tests.
 */
@VisibleForTesting
int countBuffersOfSize(int size) {
  Queue<WeakReference<ByteBuffer>> list = buffersBySize.get(size);
  if (list == null) {
    return 0;
  }
  
  return list.size();
}
 

import java.util.Queue; //导入方法依赖的package包/类
public int count() {
    Queue<Object> q = this.queue;
    if (q == null) {
        return 0;
    }
    return q.size();
}
 

import java.util.Queue; //导入方法依赖的package包/类
/**
 * Compute Operations with values
 */
protected float computeOperations(Queue<Float> values, Queue<String> operations) {
    String operation;
    float calculation = 0;
    // base case when no operators on screen
    if (operations.size() == 0 && values.size() == 1) {
        return values.remove();
    }
    int i = 0;
    while (operations.size() > 0) {
        operation = operations.remove();
        switch (operation) {
            case MINUS_CHAR:
                //first iteration two values can be used at the same time
                if (i == 0 && values.size() >= 2) {
                    calculation = computeSubsctraction(values.remove(), values.remove());
                } else if (values.size() > 0) {
                    calculation = computeSubsctraction(calculation, values.remove());
                }
                break;
            case PLUS_CHAR:
            default:
                //first iteration two values can be used at the same time
                if (i == 0 && values.size() >= 2) {
                    calculation = computeAddition(values.remove(), values.remove());
                } else if (values.size() > 0) {
                    calculation = computeAddition(calculation, values.remove());
                }
                break;
        }
        i++;
    }
    return calculation;
}
 

import java.util.Queue; //导入方法依赖的package包/类
@Override
public synchronized int getGameElementCount() {
	int size = 0;
	for (Queue<GameElement> queue : this.gameElements) {
		size += queue.size();
	}
	return size;
}
 

import java.util.Queue; //导入方法依赖的package包/类
/**
 * <strong>使用广度优先搜索收集</strong>当前实体及其所有子孙实体到集合，叶子实体排在最前面<br/>
 * 这样才能保证先删除子孙节点，后删除父节点，避免违反外键约束
 * @param currentEntity 存放当前实体及其所有子孙实体的集合
 * @param treeEntities 所有实体的集合
 * @return 当前实体及其所有子孙实体的集合，叶子实体排在集合最前面
 */
@SuppressWarnings("unchecked")
@Transactional
private LinkedList<SelfReference<T>> bfsTraverse(SelfReference<T> currentEntity, LinkedList<SelfReference<T>> treeEntities) {

    // 无法获取子孙类目时，在事务中重新获取当前节点
    try {
        currentEntity.getChildren().size();
    } catch (LazyInitializationException e) {
        ID id = (ID) ((BaseEntity)currentEntity).getId();
        currentEntity = (SelfReference<T>) findOne(id);
    }

    // 队列，用于广度优先遍历。每一时刻，队列所包含的节点是那些本身已经被访问，而它的邻居(这里即子节点)还有未被访问的节点
    Queue<SelfReference<T>> queue = new ArrayDeque<>();
    treeEntities.addFirst(currentEntity); // 对当前遍历到的元素执行的操作：加在头部，后续用于删除节点(避免违反外键约束)
    queue.add(currentEntity); // 加在尾部

    while (queue.size() != 0) { // 直到队列为空
        SelfReference<T> parent = queue.remove(); // 移除在队列头部的节点

        if(parent.getChildren().size() != 0) {
            parent.getChildren().forEach(child -> {
                treeEntities.addFirst((SelfReference<T>) child); // 对当前遍历到的元素执行的操作：加在头部
                queue.add((SelfReference<T>) child); // 加在尾部
            });
        }
    }

    return treeEntities;
}
 

import java.util.Queue; //导入方法依赖的package包/类
private static void remove(Iterator<Integer> it,
                           Queue<Integer> q) {
    int size = q.size();
    it.remove();
    removeIsCurrentlyIllegal(it);
    equal(size, q.size()+1);
}
 

import java.util.Queue; //导入方法依赖的package包/类
@Override
  public void onReceiveComplete(int id, int e, MPIBuffer buffer) {
    lock.lock();
    try {
      // we need to try to build the message here, we may need many more messages to complete
//      LOG.info(String.format("%d received message from %d", executor, id));
      MPIMessage currentMessage = currentMessages.get(id);
      ByteBuffer byteBuffer = buffer.getByteBuffer();
      byteBuffer.position(buffer.getSize());
      byteBuffer.flip();
      if (currentMessage == null) {
        currentMessage = new MPIMessage(id, type, MPIMessageDirection.IN, this);
        if (isKeyed) {
          currentMessage.setKeyType(keyType);
        }
        currentMessages.put(id, currentMessage);
        MessageHeader header = messageDeSerializer.buildHeader(buffer, e);
//        LOG.info(String.format("%d header source %d length %d", executor,
//            header.getSourceId(), header.getLength()));
        currentMessage.setHeader(header);
        currentMessage.setHeaderSize(16);
      }
      // lets rewind to 0
      currentMessage.addBuffer(buffer);
      currentMessage.build();

      if (currentMessage.isComplete()) {
//        LOG.info(String.format("%d completed recv ", executor));
        currentMessages.remove(id);
        Queue<MPIMessage> deserializeQueue = pendingReceiveDeSerializations.get(id);
        if (!deserializeQueue.offer(currentMessage)) {
          throw new RuntimeException(executor + " We should have enough space: "
              + deserializeQueue.size());
        }
      }
    } finally {
      lock.unlock();
    }
  }
 

import java.util.Queue; //导入方法依赖的package包/类
private static <V> List<V> takeQueue(Queue<V> queue) {
    int size = queue.size();

    if (size == 0) {
        return null;
    }
    List<V> result = new ArrayList<>(size);

    for (int i = 0; i < size; i++) {
        result.add(queue.poll());
    }
    return result;
}