Java Stack.empty方法代码示例

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Declare a mapping of a prefix to namespace URI at the given element depth.
 * @param prefix a String with the prefix for a qualified name
 * @param uri a String with the uri to which the prefix is to map
 * @param elemDepth the depth of current declaration
 */
boolean pushNamespace(String prefix, String uri, int elemDepth)
{
    // Prefixes "xml" and "xmlns" cannot be redefined
    if (prefix.startsWith(XML_PREFIX))
    {
        return false;
    }

    Stack stack;
    // Get the stack that contains URIs for the specified prefix
    if ((stack = (Stack) m_namespaces.get(prefix)) == null)
    {
        m_namespaces.put(prefix, stack = new Stack());
    }

    if (!stack.empty() && uri.equals(((MappingRecord)stack.peek()).m_uri))
    {
        return false;
    }
    MappingRecord map = new MappingRecord(prefix,uri,elemDepth);
    stack.push(map);
    m_nodeStack.push(map);
    return true;
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
    * Get naming context full name.
    */
   private String getNamingContextName() {
if (namingContextName == null) {
    Container parent = getParent();
    if (parent == null) {
	namingContextName = getName();
    } else {
	Stack stk = new Stack();
	StringBuffer buff = new StringBuffer();
	while (parent != null) {
	    stk.push(parent.getName());
	    parent = parent.getParent();
	}
	while (!stk.empty()) {
	    buff.append("/" + stk.pop());
	}
	buff.append(getName());
	namingContextName = buff.toString();
    }
}
return namingContextName;
   }
 

import java.util.Stack; //导入方法依赖的package包/类
public static String solve(String s) {
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '[' || c == '{') stack.push(c);
        else {
            if (stack.empty()) return "no";
            char p = stack.pop();
            if (c == ')') {
                if (p != '(') return "no";
                else continue;
            }
            if (c == ']') {
                if (p != '[') return "no";
                else continue;
            }
            if (c == '}') {
                if (p != '{') return "no";
            }
        }
    }
    return stack.empty() ? "yes" : "no";
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * 对菜单进行重排序
 *
 * @param menuList  菜单
 * @param parentIds 父级ID
 * @param resList   重排结果
 */
private static void menuSort(List<Menu> menuList, Stack<String> parentIds, List<Menu> resList) {
    if (menuList == null || menuList.size() == 0 || parentIds.empty()) {
        return;
    }
    boolean hasChild = false;
    for (Menu menu : menuList) {
        if (menu.getParentId().equals(parentIds.peek())) {
            resList.add(menu);
            parentIds.push(menu.getId());
            menuList.remove(menu);
            hasChild = true;
            break;
        }
    }
    if (!hasChild) {
        parentIds.pop();
    }
    menuSort(menuList, parentIds, resList);
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Get naming context full name.
 */
private String getNamingContextName() {
if (namingContextName == null) {
    Container parent = getParent();
    if (parent == null) {
    namingContextName = getName();
    } else {
    Stack<String> stk = new Stack<String>();
    StringBuilder buff = new StringBuilder();
    while (parent != null) {
        stk.push(parent.getName());
        parent = parent.getParent();
    }
    while (!stk.empty()) {
        buff.append("/" + stk.pop());
    }
    buff.append(getName());
    namingContextName = buff.toString();
    }
}
return namingContextName;
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Including super class fields.
 */
List<VariableElement> getAllFields(TypeElement subclazz) {
    List<VariableElement> fields = new ArrayList<VariableElement>();
    TypeElement cd = null;
    Stack<TypeElement> s = new Stack<TypeElement>();

    cd = subclazz;
    while (true) {
        s.push(cd);
        TypeElement c = (TypeElement) (types.asElement(cd.getSuperclass()));
        if (c == null)
            break;
        cd = c;
    }

    while (!s.empty()) {
        cd = s.pop();
        fields.addAll(ElementFilter.fieldsIn(cd.getEnclosedElements()));
    }

    return fields;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public static void printStack(Stack s,String title,JTextArea t)
{
	Stack s1 = (Stack)s.clone();
	String output = newLineStr + title + ":";
	while (!s1.empty())
	{
		Entry entry = (Entry)s1.pop();
		String str = TabConverter.revert(entry.getPart());
		output += (newLineStr + str);
		int tag = entry.getTag();
		if(tag != -1)
			str = " < " + analyser.Analyser.Tags.getString(String.valueOf(tag)) + " > ";
		else str = "";

		output += (str);
	}

	output += newLineStr + "---------------";
	t.append(output);
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
Checks if a string is balanced or not.

 @param s is a non-null string
 @return true of the input <code>s</code> is balanced and false otherwise.
**/
public static boolean isBalanced(String s){
  Stack<Character> stack = new Stack<Character>();
  HashMap<Character, Character> symbols = new HashMap<Character, Character>();

  symbols.put(')' , '(');
  symbols.put('}' , '{');
  symbols.put(']' , '[');

  for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if (symbols.containsValue(c)) {
      stack.push(c);
    }
    if (symbols.containsKey(c)) {
      if (stack.empty()) {
        return false;
      } else {
        Character temp = stack.pop();
        if (temp != symbols.get(c)) {
          return false;
        }
      }
    }
  }
  if (stack.empty()) {
    return true;
  }
  return false;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public static void main(String [] args) throws Exception{
    LinkedList<String> listOfFiles = new LinkedList<>();
    File baseDirectory = new File("");
    Stack<File> dirStack = new Stack<>();
    dirStack.push(baseDirectory);
    System.out.println(baseDirectory.getCanonicalFile());
    while (!dirStack.empty()){
        File currentFile = dirStack.pop().getCanonicalFile();
        if(currentFile.isDirectory()){
            File [] files = currentFile.listFiles();
            for(File f:files){
                dirStack.push(f);
            }
        }else{
            if(currentFile.toString().endsWith(".java")) {
                listOfFiles.add(currentFile.getAbsolutePath());
            }
        }
    }
    listOfFiles.addFirst("src");
    listOfFiles.addFirst("--module-source-path");
    listOfFiles.addFirst("mods");
    listOfFiles.addFirst("-d");
    listOfFiles.addFirst("javac");
    runProcessAndWaitForCompletion(listOfFiles.toArray(new String[0]));
    listOfFiles.clear();
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Collect definitions of l in body including the definitions of aliases of l.
 *                                                                                                                                                                                           
 * In this context an alias is a local that propagates its value to l.
 *
 * @param l the local whose definitions are to collect
 * @param localDefs the LocalDefs object
 * @param body the body that contains the local
 */
protected List<Unit> collectDefinitionsWithAliases(Local l) {
  Set<Local> seenLocals = new HashSet<Local>();
  Stack<Local> newLocals = new Stack<Local>();
  List<Unit> defs = new LinkedList<Unit>();
  newLocals.push(l);

  while (!newLocals.empty()) {
    Local local = newLocals.pop();
    logger.debug("[null local] "+ local);
    if (seenLocals.contains(local))
      continue;
    for (Unit u : collectDefinitions(local)) {
      if (u instanceof AssignStmt) {
        Value r = (Value) ((AssignStmt) u).getRightOp();
        if (r instanceof Local && ! seenLocals.contains((Local) r)) 
          newLocals.push((Local) r); 
      }   
      defs.add(u);
      //  
      @SuppressWarnings("unchecked")
      List<UnitValueBoxPair> usesOf = (List<UnitValueBoxPair>) localUses.getUsesOf(u);
      for (UnitValueBoxPair pair : usesOf) {
        Unit unit = pair.getUnit();
        if (unit instanceof AssignStmt) {
          Value right = (Value) ((AssignStmt) unit).getRightOp();
          Value left = (Value) ((AssignStmt) unit).getLeftOp();
          if (right == local  && left instanceof Local && ! seenLocals.contains((Local) left))
            newLocals.push((Local) left);
        }   
      }   
      //  
    }   
    seenLocals.add(local);
  }   
  return defs;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public static Vector analyse(String input)
	{
		Vector output = new Vector();
try
{
		Stack allStk = new Stack();
		Method.analyse(input,allStk);
		for(int i=0;i<allStk.size();i++)
		{
			Stack outputStack = (Stack)allStk.get(i);
			Vector part = new Vector();
			Vector tag = new Vector();
			while (!outputStack.empty())
			{
				Entry entry = (Entry)outputStack.pop();
				String s = TabConverter.revert(entry.getPart());
				part.add(s);
				int tagInt = entry.getTag();
				if(tagInt != -1)
				{
					s = String.valueOf(tagInt);
				}
				else
					s = "";
				tag.add(s);
			}
			output.add(new Element(part,tag));
		}
}catch(Exception e)
{
	System.err.println("Analyser analyse: " + e);
	e.printStackTrace();
	return null;
}
	return output;
	}
 

import java.util.Stack; //导入方法依赖的package包/类
public void printListReversingly (ListNode head) {
    Stack<ListNode> stack = new Stack<ListNode>();
    ListNode temp = head;
    while (temp != null) {
        stack.push(temp);
        temp = temp.next;
    }

    while (!stack.empty()) {
        ListNode node = stack.peek();
        System.out.print(node.val + " ");
        stack.pop();
    }
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Find mime type for a given editor kit implementation class.
 * 
 * @param kitClass The editor kit class to get the mime type for.
 * @return The mime type or <code>null</code> if the mime type can't be
 *   resolved for the given kit class.
 */
public String findMimeType(Class kitClass) {
    if (kitClass != null) {
        if (WELL_KNOWN_PARENTS.contains(kitClass.getName())) {
            // these classes are not directly registered as a kit for any mime type
            return null;
        }

        String contextMimeType = null;
        Stack<String> context = contexts.get();
        if (context != null && !context.empty()) {
            contextMimeType = context.peek();
        }
        
        if (contextMimeType == null || contextMimeType.length() == 0) {
            List mimeTypes = getMimeTypesForKitClass(kitClass);
            if (mimeTypes.size() == 0) {
                if (LOG.isLoggable(Level.WARNING) && !DYNAMIC_LANGUAGES.contains(kitClass.getName())) {
                    logOnce(Level.WARNING, "No mime type uses editor kit implementation class: " + kitClass); //NOI18N
                }
                return null;
            } else if (mimeTypes.size() == 1) {
                return (String) mimeTypes.get(0);
            } else {
                if (LOG.isLoggable(Level.WARNING)) {
    //                Throwable t = new Throwable("Stacktrace"); //NOI18N
    //                LOG.log(Level.WARNING, "Ambiguous mime types for editor kit implementation class: " + kitClass + "; mime types: " + mimeTypes, t); //NOI18N
                    logOnce(Level.WARNING, "Ambiguous mime types for editor kit implementation class: " + kitClass + "; mime types: " + mimeTypes); //NOI18N
                }
                return null;
            }
        } else{
            return contextMimeType;
        }
    } else {
        return ""; //NOI18N
    }
}
 

import java.util.Stack; //导入方法依赖的package包/类
@Nullable
private String buildUrnKeyForFile(@NotNull PsiFile psiFile, @NotNull MagentoComponent magentoComponent) {
    String prefix = null;

    if (magentoComponent instanceof MagentoModule) {
        prefix = MODULE + ((MagentoModule)magentoComponent).getMagentoName() + ":";
    } else {
        ComposerPackageModel composerPackageModel = magentoComponent.getComposerModel();
        if ("magento2-library".equals(composerPackageModel.getType())) {
            prefix = FRAMEWORK;
        }
    }

    if (prefix == null) {
        return null;
    }

    Stack<String> relativePath = new Stack<>();
    relativePath.push(psiFile.getName());

    PsiManager psiManager = magentoComponent.getDirectory().getManager();
    PsiDirectory parentDir = psiFile.getParent();
    while (parentDir != null && !psiManager.areElementsEquivalent(parentDir, magentoComponent.getDirectory())) {
        relativePath.push("/");
        relativePath.push(parentDir.getName());
        parentDir = parentDir.getParentDirectory();
    }

    StringBuilder stringBuilder = new StringBuilder(prefix);
    while (!relativePath.empty()) {
        stringBuilder.append(relativePath.pop());
    }

    return stringBuilder.toString();
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Read lines one at a time from r.  After reading all lines, output
 * all lines to w, outputting duplicate lines only once.  Note: the order
 * of the output is unspecified and may have nothing to do with the order
 * that lines appear in r.
 * @param r the reader to read from
 * @param w the writer to write to
 * @throws IOException
 */
public static void doIt(BufferedReader r, PrintWriter w) throws IOException {
			Stack<String> stack = new Stack<String>();

       for (String line = r.readLine(); line != null; line = r.readLine()) {
           stack.push(line);
       }

			while (!stack.empty()) {
				w.println(stack.pop());
			}
}