Java Stack.push方法代码示例

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Execute the inheriting instruction.
 *
 * @param frame The currently executed frame.
 */
@Override
public void execute(Frame frame) {
	Stack<Object> stack = frame.getOperandStack();
	Float value2 = (Float) stack.pop();
	Float value1 = (Float) stack.pop();
	if (value1.isNaN() || value2.isNaN()) {
		stack.push(getPushValueForNaN());
	} else if (value1 > value2) {
		stack.push(Integer.valueOf(1));
	} else if (value1 < value2) {
		stack.push(Integer.valueOf(-1));
	} else {
		stack.push(Integer.valueOf(0));
	}
}
 

import java.util.Stack; //导入方法依赖的package包/类
public static Boolean isPalindrome2(Node head) {
	if (head == null)
		return false;
	Node slow = head;
	Node fast = head;
	Stack<Integer> sta = new Stack<Integer>();
	while (fast != null && fast.next != null) {
		sta.push(slow.value);
		slow = slow.next;
		fast = fast.next.next;
	}
	if (fast != null)// 如果有奇数个节点，slow再往后移动一个
		slow = slow.next;

	while (!sta.isEmpty()) {
		if (sta.pop() != slow.value)
			return false;
		slow = slow.next;
	}
	return true;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public static TreePath getTreePath(JTreeOperator treeOperator, String targetNode, NodeConverter converter) {
    Stack<TreeNode> lifo = new Stack<TreeNode>();        
    lifo.push((TreeNode) treeOperator.getRoot());
    while(!lifo.isEmpty()) {
        TreeNode actNode = lifo.pop();
        if(targetNode.equals(converter.getDisplayName(actNode))) {
            List<TreeNode> path = new LinkedList<TreeNode>();
            path.add(actNode);
            actNode = actNode.getParent();
            while(actNode!=null) {
                path.add(0,actNode);
                actNode = actNode.getParent();
            }
            TreeNode[] res = path.toArray(new TreeNode[path.size()]);                
            return new TreePath(res);
        }
        final Enumeration children = actNode.children();            
        while(children.hasMoreElements()) {
            lifo.add((TreeNode)children.nextElement());
        }            
    }
    return null;
}
 

import java.util.Stack; //导入方法依赖的package包/类
private boolean unmatchedQuotesIn(final String str) {
    final Stack<Character> quoteStack = new Stack<>();
    for (int i = 0; i < str.length(); i++) {
        final char c = str.charAt(i);
        for (final char q : this.quotes) {
            if (c == q) {
                if (quoteStack.isEmpty()) {
                    quoteStack.push(c);
                } else {
                    final char top = quoteStack.pop();
                    if (top != c) {
                        quoteStack.push(top);
                        quoteStack.push(c);
                    }
                }
            }
        }
    }

    return !quoteStack.isEmpty();
}
 

import java.util.Stack; //导入方法依赖的package包/类
static boolean type5(Stack s)
{
	//5 - doubling
	byte[] topElmt = ((Entry)s.peek()).getPart();
	byte[] oldTopElmt = topElmt;
	byte[] sandhi = BooleanMethod.endswith_doubling_Letter(topElmt);
	if(sandhi != null)
	{
		//System.out.println(x + "type 5");
		s.pop();
		topElmt = ByteMeth.subArray(topElmt,0,
			topElmt.length-sandhi.length);
		s.push(new Entry(sandhi,Tag.Sandhi));
		s.push(new Entry(topElmt,-1,oldTopElmt));
		return true;
	}
	return false;
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Execute the instruction.
 * @param frame The currently executed frame.
 * @throws ExecutionException Thrown in case of fatal problems during the execution.
 */
@Override
@SuppressWarnings("unused")
public void execute(Frame frame) throws ExecutionException {
	Stack<Object> stack = frame.getOperandStack();
	stack.push(((Float) stack.pop()).longValue());
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Checks to see if an end tag exists for a start tag at a given offset.
 * @param document
 * @param offset
 * @return true if an end tag is found for the start, false otherwise.
 */
public static boolean hasEndTag(Document document, int offset, String startTag) {
    AbstractDocument doc = (AbstractDocument)document;
    doc.readLock();
    try {
        TokenHierarchy th = TokenHierarchy.get(doc);
        TokenSequence ts = th.tokenSequence();
        Token token = findTokenAtContext(ts, offset);
        Stack<String> stack = new Stack<String>();
        while(ts.moveNext()) {
            Token t = ts.token();
            if(XMLTokenId.TAG != t.id())
                continue;
            String tag = t.text().toString();
            if(">".equals(tag))
                continue;
            if(stack.empty()) {
                if(("</"+startTag).equals(tag)) {
                    stack.empty();
                    stack = null;
                    return true;
                }
            } else {                
                if(tag.equals("/>") || ("</"+stack.peek()).equals(tag)) {
                    stack.pop();
                    continue;
                }
            }
            stack.push(tag.substring(1));
        }            
    } finally {
        doc.readUnlock();
    }
    
    return false;
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Execute the instruction symbolically.
 * @param frame The currently executed frame.
 * @throws SymbolicExecutionException Thrown in case of fatal problems during the symbolic execution.
 */
@Override
public void executeSymbolically(Frame frame) throws SymbolicExecutionException {
	try {
		Stack<Object> stack = frame.getOperandStack();
		Object value1 = stack.pop();
		Object value2 = stack.pop();
		if (!checkCategory2(value1) && checkCategory2(value2)) {
			// Form 2: value1 is a type of category 1, while value2 is a type of category 2.
			stack.push(value2);
			stack.push(value1);
		} else {
			Object value3 = stack.pop();
			if (!(checkCategory2(value1) || checkCategory2(value2) || checkCategory2(value3))) {
				// Form 1: All three values are types of category 1.
				stack.push(value1);
				stack.push(value3);
				stack.push(value2);
				stack.push(value1);
			} else {
				// Recovery.
				stack.push(value3);
				stack.push(value2);
				stack.push(value1);
				throw new ExecutionException("When using " + getName() + " either the three topmost values of the operand stack must not be category 2 types, or the topmost value must be a category 1 type, while the second one must be a category 2 type.");
			}
		}
	} catch (ExecutionException e) {
		symbolicExecutionFailedWithAnExecutionException(e);
	}
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Execute the instruction.
 * @param frame The currently executed frame.
 * @throws ExecutionException Thrown in case of fatal problems during the execution.
 */
@Override
@SuppressWarnings("unused")
public void execute(Frame frame) throws ExecutionException {
	Stack<Object> stack = frame.getOperandStack();
	stack.push((Double) stack.pop() * -1D);
}
 

import java.util.Stack; //导入方法依赖的package包/类
public void preorderTraverse() {
    Stack<TreeNode<String>> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode<String> node = stack.pop();
        if (null == node) continue;
        System.out.print(node.getValue() + " ");
        stack.push(node.getRight());
        stack.push(node.getLeft());
    }
}
 

import java.util.Stack; //导入方法依赖的package包/类
private SchemaCompatibilityResult checkReaderEnumContainsAllWriterEnumSymbols(
    final Schema reader, final Schema writer, final Stack<String> location) {
  SchemaCompatibilityResult result = SchemaCompatibilityResult.compatible();
  location.push("symbols");
  final Set<String> symbols = new TreeSet<String>(writer.getEnumSymbols());
  symbols.removeAll(reader.getEnumSymbols());
  if (!symbols.isEmpty()) {
    result = SchemaCompatibilityResult.incompatible(
        SchemaIncompatibilityType.MISSING_ENUM_SYMBOLS, reader, writer,
        symbols.toString(), location);
  }
  // POP "symbols" literal
  location.pop();
  return result;
}
 

import java.util.Stack; //导入方法依赖的package包/类
private int applyValueToSingleValuedField(Field field,
                                          Range arity,
                                          Stack<String> args,
                                          Class<?> cls,
                                          Set<Field> initialized) throws Exception {
    boolean noMoreValues = args.isEmpty();
    String value = args.isEmpty() ? null : trim(args.pop()); // unquote the value
    int result = arity.min; // the number or args we need to consume

    // special logic for booleans: BooleanConverter accepts only "true" or "false".
    if ((cls == Boolean.class || cls == Boolean.TYPE) && arity.min <= 0) {

        // boolean option with arity = 0..1 or 0..*: value MAY be a param
        if (arity.max > 0 && ("true".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value))) {
            result = 1;            // if it is a varargs we only consume 1 argument if it is a boolean value
        } else {
            if (value != null) {
                args.push(value); // we don't consume the value
            }
            Boolean currentValue = (Boolean) field.get(command);
            value = String.valueOf(currentValue == null ? true : !currentValue); // #147 toggle existing boolean value
        }
    }
    if (noMoreValues && value == null) {
        return 0;
    }
    if (initialized != null) {
        if (initialized.contains(field) && !isOverwrittenOptionsAllowed()) {
            throw new OverwrittenOptionException(optionDescription("", field, 0) +  " should be specified only once");
        }
        initialized.add(field);
    }
    ITypeConverter<?> converter = getTypeConverter(cls);
    Object objValue = tryConvert(field, -1, converter, value, cls);
    field.set(command, objValue);
    return result;
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Execute the instruction.
 * @param frame The currently executed frame.
 * @throws ExecutionException Thrown in case of fatal problems during the execution.
 */
@Override
@SuppressWarnings("unused")
public void execute(Frame frame) throws ExecutionException {
	Stack<Object> stack = frame.getOperandStack();
	Long value2 = (Long) stack.pop();
	Long value1 = (Long) stack.pop();
	stack.push(value1 + value2);
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Execute the instruction.
 * @param frame The currently executed frame.
 */
@Override
public void execute(Frame frame) {
	Stack<Object> stack = frame.getOperandStack();
	stack.push((Long) stack.pop() | (Long) stack.pop());
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Disable this behaviour for the curent thread
 */
public void disable() 
{
    Stack<Integer> stack = disabled.get();
    stack.push(hashCode());
}