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

@Nullable
private ValueType getPeekType(@NotNull LinkedList<ExprPart> parts,
							  @NotNull LinkedList<ExprPart> removedParts,
							  @NotNull ProblemsHolder problems,
							  @NotNull LinkedList<PotentialProblem> potentialProblems,
							  @NotNull Counter reportCount) {
	ExprPart peekPart = parts.peekFirst();
	if (peekPart == null) {
		return null;
	}
	if (peekPart.isOperatorPart()) {
		return getReturnTypeForCommand(
				parts,
				null,
				problems,
				potentialProblems,
				reportCount,
				true
		);
	} else {
		removedParts.push(parts.removeFirst());
		return peekPart.getArgument().getType(this, true, cluster);
	}
}
 

@Nullable
private ValueType getPeekType(@NotNull LinkedList<ExprPart> parts,
							  @NotNull LinkedList<ExprPart> removedParts,
							  @NotNull ProblemsHolder problems,
							  @NotNull LinkedList<PotentialProblem> potentialProblems,
							  @NotNull Counter reportCount) {
	ExprPart peekPart = parts.peekFirst();
	if (peekPart == null) {
		return null;
	}
	if (peekPart.isOperatorPart()) {
		return getReturnTypeForCommand(
				parts,
				null,
				problems,
				potentialProblems,
				reportCount,
				true
		);
	} else {
		removedParts.push(parts.removeFirst());
		return peekPart.getArgument().getType(this, true, cluster);
	}
}
 

/**
 * スタックの先頭の要素（一番上の要素）が引数で指定した文字列の何れかと等しいかどうか比較する。
 * @param stack
 * @param strs 比較する文字列の配列
 * @return
 */
public static boolean equalsAnyTopElement(final LinkedList<String> stack, final String[] strs) {
    
    ArgUtils.notNull(stack, "stack");
    ArgUtils.notEmpty(strs, "strs");
    
    if(stack.isEmpty()) {
        return false;
    }
    
    final String top = stack.peekFirst();
    for(String str : strs) {
        if(str.equals(top)) {
            return true;
        }
    }
    
    return false;
    
}
 

/**
 * スタックの先頭の要素（一番上の要素）が引数で指定した文字列の何れかと等しいかどうか比較する。
 * @param stack
 * @param strs 比較する文字列の配列
 * @return
 */
public static boolean equalsAnyTopElement(final LinkedList<String> stack, final String[] strs) {
    
    Objects.requireNonNull("stack should not be null.");
    Objects.requireNonNull("strs should not be null.");
    
    if(stack.isEmpty()) {
        return false;
    }
    
    final String top = stack.peekFirst();
    for(String str : strs) {
        if(str.equals(top)) {
            return true;
        }
    }
    
    return false;
    
}
 

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;
}
 

/**
 * 使用双向最大最小值更新结构，时间复杂度为 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;
}
 

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;
}
 

/**
 * 两个链表前面的结点都是相同的，找到最后一个相同的结点就是最低公共祖先
 */
private Node getLastSameNode(LinkedList<Node> path1, LinkedList<Node> path2) {
    Node lastSameNode = null;
    while (!path1.isEmpty() && !path2.isEmpty()) {
        if (path1.peekFirst() == path2.removeFirst()) {
            lastSameNode = path1.removeFirst();
        } else {
            return lastSameNode;
        }
    }
    return lastSameNode;
}
 

@Override
public synchronized Partition least() {
	if (!this.records.isEmpty()) {
		// Expired clean.
		this.checkExpiredSampleClean();

		LinkedList<Partition> records0 = this.getASCRecords();
		Partition part = records0.peekFirst();
		if (part != null) {
			part.setSamples(records0.size());
			return part;
		}
	}
	return null;
}
 

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();
}
 

@Override
public LineReader reader(final int width) {


  final LinkedList<LineReader> readers  = new LinkedList<LineReader>();
  for (LineRenderer child : children) {
    readers.addLast(child.reader(width - 2));
  }

  //
  return new LineReader() {

    /** . */
    LineReader value = TreeLineRenderer.this.value != null ? TreeLineRenderer.this.value.reader(width) : null;

    /** . */
    boolean node = true;

    public boolean hasLine() {
      if (value != null) {
        if (value.hasLine()) {
          return true;
        } else {
          value = null;
        }
      }
      while (readers.size() > 0) {
        if (readers.peekFirst().hasLine()) {
          return true;
        } else {
          readers.removeFirst();
          node = true;
        }
      }
      return false;
    }

    public void renderLine(RenderAppendable to) {
      if (value != null) {
        if (value.hasLine()) {
          value.renderLine(to);
        } else {
          value = null;
        }
      }
      if (value == null) {
        while (readers.size() > 0) {
          LineReader first = readers.peekFirst();
          if (first.hasLine()) {
            if (node) {
              to.append("+-");
              node = false;
            } else {
              Iterator<LineReader> i = readers.descendingIterator();
              boolean rest = false;
              while (i.hasNext()) {
                LineReader renderer = i.next();
                if (i.hasNext()) {
                  if (renderer.hasLine()) {
                    rest = true;
                    break;
                  }
                }
              }
              if (rest) {
                to.append("| ");
              } else {
                to.append("  ");
              }
            }
            first.renderLine(to);
            break;
          }
        }
      }
    }
  };
}