Java Code Examples for java.util.LinkedList#pollFirst()

public static int getNum(LinkedList<String> que) {
    int res = 0;
    boolean add = true;
    String cur = null;
    int num = 0;
    while (!que.isEmpty()) {
        cur = que.pollFirst();
        if (cur.equals("+")) {
            add = true;
        } else if (cur.equals("-")) {
            add = false;
        } else {
            num = Integer.valueOf(cur);
            res += add ? num : (-num);
        }
    }
    return res;
}
 

public void dump(ByteBuf buffer, Map<String, PullLogIndexEntry> indexMap) {
    for (Map.Entry<String, PullLogSequence> entry : messageSequences.entrySet()) {
        LinkedList<Range> messagesInRange = entry.getValue().messagesInRange;
        Range first = messagesInRange.pollFirst();
        if (first == null) continue;

        long baseMessageSequence = first.start;
        PullLogIndexEntry indexEntry = new PullLogIndexEntry(entry.getValue().basePullSequence, baseMessageSequence, buffer.writerIndex(), messagesInRange.size());
        indexMap.put(entry.getKey(), indexEntry);
        for (Range range : messagesInRange) {
            for (long i = range.start; i <= range.end; ++i) {
                buffer.writeInt((int) (i - baseMessageSequence));
            }
        }
    }
}
 

public static Set<Long> get_all_children(Joern_db joern_db, Long node_id)
{
Set<Long> children = new HashSet<>();
LinkedList<Long> new_nodes = new LinkedList<>();
 new_nodes.add(node_id);
  while(!new_nodes.isEmpty())
   {
   Long cur = new_nodes.pollFirst();
   List<Node> its_children = Pipeline.v(cur).children().to_list();
     for(Node c : its_children)
      {
        if(children.contains(c.getId()))
         {
          continue;
         }
        new_nodes.add(c.getId());
        children.add(c.getId());
      }
   }
 return children;
}
 

/**
 * 使用双向最大最小值更新结构，时间复杂度为 O（N）
 */
public static int getNum(int[] arr, int num) {
    if (arr == null || arr.length == 0) {
        return 0;
    }
    // 分别准备最大值和最小值更新结构
    LinkedList<Integer> qmax = new LinkedList<Integer>();
    LinkedList<Integer> qmin = new LinkedList<Integer>();
    int L = 0;
    int R = 0;
    int res = 0;
    while (L < arr.length) {
        while (R < arr.length) {
            while (!qmin.isEmpty() && arr[qmin.peekLast()] >= arr[R]) {
                qmin.pollLast();
            }
            qmin.addLast(R);
            while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[R]) {
                qmax.pollLast();
            }
            qmax.addLast(R);
            // 不达标
            if (arr[qmax.getFirst()] - arr[qmin.getFirst()] > num) {
                break;
            }
            R++;
        }
        if (qmin.peekFirst() == L) {
            qmin.pollFirst();
        }
        if (qmax.peekFirst() == L) {
            qmax.pollFirst();
        }
        res += R - L;
        // 换一个开头
        L++;
    }
    return res;
}
 

private static void compareJson(LinkedList<String> arguments) throws IOException {
  String oldJsonPath = arguments.pollFirst();
  String newJsonPath = arguments.pollFirst();

  File oldJsonFile = new File(oldJsonPath);
  checkExist(oldJsonFile);
  File newJsonFile = new File(newJsonPath);
  checkExist(newJsonFile);

  ObjectMapper mapper = new ObjectMapper();
  ThriftType.StructType oldStruct = mapper.readValue(oldJsonFile, ThriftType.StructType.class);
  ThriftType.StructType newStruct = mapper.readValue(newJsonFile, ThriftType.StructType.class);

  CompatibilityReport report = new CompatibilityChecker().checkCompatibility(oldStruct, newStruct);
  if (!report.isCompatible) {
    System.err.println("schema not compatible");
    System.err.println(report.getMessages());
    System.exit(1);
  }

  if (report.hasEmptyStruct()) {
    System.err.println("schema contains empty struct");
    System.err.println(report.getMessages());
    System.exit(1);
  }

  System.out.println("[success] schema is compatible");

}
 

public static void main(String[] args) throws Exception {
  LinkedList<String> arguments = new LinkedList<String>(Arrays.asList(args));
  String operator = arguments.pollFirst();
  if (operator.equals("generate-json")) {
    //java CompatibilityRunner generate-json tfe_request com.twitter.logs.TfeRequestLog old_json/
    generateJson(arguments);
  }

  if (operator.equals("compare-json")) {
    compareJson(arguments);
  }
}
 

/**
 * スタックから先頭の値を取り出す。
 * @param stack
 * @return スタックが空の場合は空文字を返す。
 */
public static String popup(final LinkedList<String> stack) {
    
    if(stack.isEmpty()) {
        return "";
    }
    
    return stack.pollFirst();
}
 

protected static void closeEntries ( final List<ImportEntry> entries ) throws Exception
{
    final LinkedList<Exception> errors = new LinkedList<> ();

    // close all

    for ( final ImportEntry entry : entries )
    {
        try
        {
            entry.close ();
        }
        catch ( final Exception e )
        {
            errors.add ( e );
        }
    }

    // throw later

    if ( !errors.isEmpty () )
    {
        final Exception first = errors.pollFirst ();
        for ( final Exception ex : errors )
        {
            first.addSuppressed ( ex );
        }
        throw first;
    }
}
 

public CleanerConfig verify() throws RuntimeException {

        final LinkedList<RuntimeException> result = new LinkedList<>();

        if (getTenantId() == null) {
            result.add(missingField("tenantId"));
        }
        if (this.infinispan.getHost().isBlank()) {
            result.add(missingField("infinispan.host"));
        }
        if (this.infinispan.getPort() <= 0) {
            result.add(missingField("infinispan.port"));
        }
        if (this.infinispan.getCacheNames().getDevices().isBlank()) {
            result.add(missingField("infinispan.devicesCacheName"));
        }
        if (this.infinispan.getCacheNames().getDeviceConnections().isBlank()) {
            result.add(missingField("infinispan.deviceStatesCacheName"));
        }

        // create result

        final RuntimeException e = result.pollFirst();
        if (e != null) {
            result.forEach(e::addSuppressed);
            throw e;
        }

        return this;
    }
 

public static void BFSExplore(LinkedList< Integer >[] adjacencyList, LinkedList<Integer> queue, int[] parent) {
    if (queue.isEmpty()) {
        return;
    }
    
    int vertex = queue.pollFirst();
    System.out.println("vertex = " + vertex);
    
    for (int adjacentVertex : adjacencyList[vertex]) {
        if (parent[adjacentVertex] == Integer.MAX_VALUE) {  // if parent is not set, it is unvisited
            parent[adjacentVertex] = vertex;
            queue.add(adjacentVertex);
        }
    }
}
 

private String transferThroughList(String in, int index) {
    LinkedList<String> list = new LinkedList<String>();
    list.add(System.getenv("")); // taints the list
    list.clear(); // makes the list safe again
    list.add(1, "xx");
    list.addFirst(in); // can taint the list
    list.addLast("yy");
    list.push(in);
    return list.element() + list.get(index) + list.getFirst() + list.getLast()
            + list.peek() + list.peekFirst() + list.peekLast() + list.poll()
            + list.pollFirst() + list.pollLast() + list.pop() + list.remove()
            + list.remove(index) + list.removeFirst() + list.removeLast()
            + list.set(index, "safe") + list.toString();
}
 

static private boolean processInheritors(final String qName, final PsiElement context, final Processor<? super PsiElement> consumer) {
  final Set<String> namesSet = new THashSet<String>();
  final LinkedList<String> namesQueue = new LinkedList<String>();
  namesQueue.add(qName);
  final Project project = context.getProject();
  final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
  while (!namesQueue.isEmpty()) {
    final String name = namesQueue.pollFirst();
    if (!namesSet.add(name)) {
      continue;
    }
    List<List<HaxeClassInfo>> files = FileBasedIndex.getInstance().getValues(HaxeInheritanceIndex.HAXE_INHERITANCE_INDEX, name, scope);
    files.addAll(FileBasedIndex.getInstance().getValues(HaxeTypeDefInheritanceIndex.HAXE_TYPEDEF_INHERITANCE_INDEX, name, scope));
    for (List<HaxeClassInfo> subClassInfoList : files) {
      for (HaxeClassInfo subClassInfo : subClassInfoList) {
        final HaxeClass subClass = HaxeResolveUtil.findClassByQName(subClassInfo.getValue(), context.getManager(), scope);
        if (subClass != null) {
          if (!consumer.process(subClass)) {
            return true;
          }
          namesQueue.add(subClass.getQualifiedName());
        }
      }
    }
  }
  return true;
}
 

/**
 * スタックから先頭の値を取り出す。
 * @param stack
 * @return スタックが空の場合は空文字を返す。
 */
public static String popup(final LinkedList<String> stack) {
    
    if(stack.isEmpty()) {
        return "";
    }
    
    return stack.pollFirst();
}
 

private static void generateJson(LinkedList<String> arguments) throws ClassNotFoundException, IOException {
  String catName = arguments.pollFirst();
  String className = arguments.pollFirst();
  String storedPath = arguments.pollFirst();
  File storeDir = new File(storedPath);
  ThriftType.StructType structType = ThriftSchemaConverter.toStructType((Class<? extends TBase<?, ?>>) Class.forName(className));
  ObjectMapper mapper = new ObjectMapper();

  String fileName = catName + ".json";
  mapper.writerWithDefaultPrettyPrinter().writeValue(new File(storeDir, fileName), structType);
}
 

public boolean isSymmetric(TreeNode root) {
    if (root == null) {
        return true;
    }
    LinkedList<TreeNode> queue = new LinkedList<>();
    queue.addFirst(root.left);
    queue.addLast(root.right);
    while (!queue.isEmpty()) {
        // 出队的时候，看看是否有左右孩子，分别入队
        TreeNode leftNode = queue.pollFirst();
        TreeNode rightNode = queue.pollLast();
        if (leftNode == null && rightNode == null) {
            continue;
        }
        if (leftNode == null || rightNode == null) {
            return false;
        }
        queue.addFirst(leftNode.right);
        queue.addFirst(leftNode.left);
        queue.addLast(rightNode.left);
        queue.addLast(rightNode.right);

        if (leftNode.val != rightNode.val) {
            return false;
        }
    }
    return true;
}
 

@Override
public <E> Iterator<E> iterator(Class<E> clazz, InputStream stream) {
    // 实例列表
    HashMap<Object, E> instanceObjects = new HashMap<>();
    try {
        Properties properties = new Properties();
        properties.load(stream);
        Constructor<E> constructor = clazz.getDeclaredConstructor();
        ReflectionUtility.makeAccessible(constructor);

        Field storageId = ReflectionUtility.uniqueField(clazz, ResourceId.class);
        storageId.setAccessible(true);

        TreeMap<?, ?> keyValues = new TreeMap<>(properties);
        for (Entry<?, ?> keyValue : keyValues.entrySet()) {
            LinkedList<String> fieldNames = new LinkedList<>(Arrays.asList(String.class.cast(keyValue.getKey()).split(dot)));
            String fieldName = fieldNames.pollFirst();
            String fieldValue = String.class.cast(keyValue.getValue());
            Object instanceId = ConversionUtility.convert(fieldName, storageId.getGenericType());
            E instanceObject = instanceObjects.get(instanceId);
            if (instanceObject == null) {
                instanceObject = constructor.newInstance();
                storageId.set(instanceObject, instanceId);
                instanceObjects.put(instanceId, instanceObject);
            }
            if (fieldNames.isEmpty()) {
                continue;
            } else {
                fieldName = fieldNames.pollFirst();
                process(instanceObject, clazz, fieldName, fieldNames, fieldValue);
            }
        }
        return instanceObjects.values().iterator();
    } catch (Exception exception) {
        throw new StorageException("遍历Properties异常", exception);
    }
}
 

public int[] maxSlidingWindow(int[] nums, int k) {
    if (nums == null || k < 1 || nums.length < k) {
        return new int[0];
    }

    LinkedList<Integer> maxList = new LinkedList<Integer>();
    int[] res = new int[nums.length - k + 1];
    int index = 0;
    for (int i = 0; i < nums.length; i++) {
        // 更新双端队列，如果双端队列不为空，并且尾结点(存的是下标)对应数组中的值是否小于等于当前值
        while (!maxList.isEmpty() && nums[maxList.peekLast()] <= nums[i]) {
            maxList.pollLast();
        }
        // 上面一直弹出，直到不符合然后加上当前值。
        maxList.addLast(i);
        // 上面加法是通用的，但是减法是针对该题定制的
        // 当过期的时候（当窗口形成之后再扩充才算过期）即窗口长度 > k，窗口形成过程中不会过期, i - k 表示过期的下标
        if (maxList.peekFirst() == i - k) {
            maxList.pollFirst();
        }
        // 判断下标过期
        if (i >= k - 1) {
            // 当窗口已经形成了，记录每一步的res
            res[index++] = nums[maxList.peekFirst()];
        }
    }
    return res;
}
 

public static int[] getMaxWindow(int[] arr, int w) {
    if (arr == null || w < 1 || arr.length < w) {
        return null;
    }
    // LinkedList 就是一个标准的双向链表
    LinkedList<Integer> maxList = new LinkedList<Integer>();
    // 生成的结果数组
    int[] res = new int[arr.length - w + 1];
    int index = 0;
    for (int i = 0; i < arr.length; i++) {
        // 更新双端队列，如果双端队列不为空，并且尾结点(存的是下标)对应数组中的值是否小于等于当前值
        while (!maxList.isEmpty() && arr[maxList.peekLast()] <= arr[i]) {
            maxList.pollLast();
        }
        // 上面一直弹出，直到不符合然后加上当前值。
        maxList.addLast(i);
        // 上面加法是通用的，但是减法是针对该题定制的
        // 当过期的时候（当窗口形成之后再扩充才算过期）即窗口长度 > w，窗口形成过程中不会过期, i - w表示过期的下标
        if (maxList.peekFirst() == i - w) {
            maxList.pollFirst();
        }
        // 判断下标过期
        if (i >= w - 1) {
            // 当窗口已经形成了，记录每一步的res
            res[index++] = arr[maxList.peekFirst()];
        }
    }
    return res;
}
 

/**
 * Does a 'breadth first' search of ancestors, caching as it goes
 * @param nodeIds initial list of nodes to visit
 * @return all visited nodes, in no particular order
 */
private List<Long> cacheAncestors(List<Long> nodeIds)
{
    final LinkedList<Long> toVisit = new LinkedList<Long>(nodeIds);
    Set<Long> visited = new TreeSet<Long>();
    Long nodeId;
    nodeDAO.cacheNodesById(toVisit);
    Long lastCached = toVisit.peekLast();
    while ((nodeId = toVisit.pollFirst()) != null)
    {
        if (visited.add(nodeId) && (nodeDAO.getNodeIdStatus(nodeId) != null) && (false == nodeDAO.getNodeIdStatus(nodeId).isDeleted()))
        {
            nodeDAO.getParentAssocs(nodeId, null, null, null, new ChildAssocRefQueryCallback()
            {
                @Override
                public boolean preLoadNodes()
                {
                    return false;
                }

                @Override
                public boolean orderResults()
                {
                    return false;
                }

                @Override
                public boolean handle(Pair<Long, ChildAssociationRef> childAssocPair,
                        Pair<Long, NodeRef> parentNodePair, Pair<Long, NodeRef> childNodePair)
                {
                    toVisit.add(parentNodePair.getFirst());
                    return true;
                }

                @Override
                public void done()
                {
                }
            });
        }
        final boolean nodeIdEqualsLastCached = (nodeId == null && lastCached == null) ||
                                               (nodeId != null && nodeId.equals(lastCached));
        if (nodeIdEqualsLastCached && !toVisit.isEmpty())
        {
            nodeDAO.cacheNodesById(toVisit);
            lastCached = toVisit.peekLast();
        }
    }
    return new ArrayList<Long>(visited);
}
 

public void timingCompress() throws RuntimeException {
	LinkedList<CleanupRecord> removedList = new LinkedList<CleanupRecord>();

	CleanupRecord lastEnabledRecord = null;
	for (int current = CONSTANTS_START_INDEX; current < this.endIndex; current = current + CONSTANTS_RECORD_SIZE + 1) {
		int index = (current - CONSTANTS_START_INDEX) / (CONSTANTS_RECORD_SIZE + 1);
		CleanupRecord record = this.recordList.get(index);

		int memoRecordFlag = record.getRecordFlag();
		boolean memoEnabled = record.isEnabled();
		boolean forgetFlag = (memoRecordFlag & 0x2) == 0x2;

		if (memoEnabled && forgetFlag) {
			this.delete(record); // change status & unRegister record
			removedList.add(record);
			continue;
		} else if (memoEnabled == false) {
			removedList.add(record);
			this.unRegisterRecord(record); // unRegister record
			continue;
		}

		CleanupRecord removedRecord = removedList.pollFirst();
		if (removedRecord == null) {
			lastEnabledRecord = record;
			continue;
		}

		removedRecord.setEnabled(record.isEnabled());
		removedRecord.setRecordFlag(record.getRecordFlag());
		removedRecord.setResource(record.getResource());
		// removedRecord.setStartIndex(); // dont set startIndex
		removedRecord.setXid(record.getXid());

		this.forget(removedRecord);
		this.delete(record);

		removedList.add(record);

		lastEnabledRecord = removedRecord;
	} // end-for

	int lastRecordEndIndex = lastEnabledRecord == null ? //
			CONSTANTS_START_INDEX : lastEnabledRecord.getStartIndex() + CONSTANTS_RECORD_SIZE + 1;
	this.updateEndIndex(lastRecordEndIndex);
}