栈实现：多位整数带括号中缀转后缀，逆波兰计算器

package com.m.demo6;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;

public class nPolandCounter {

	public static void main(String[] args) {
//		中缀表达式转后缀表达式
//		String str="1+((2+3)*4)-5";//1 2 3 + 4 × + 5 –
		String str="8888*(234+12)-5";
//		将表达式转为List ->多位数字合并成String
		List<String> li = numsMerge(str);
		//如果有空元素则remove掉:使用迭代器删除，否则会发生并发异常
		Iterator<String> iterator = li.iterator();
		int i = 0;
		while (iterator.hasNext()) {
			if (iterator.next() == "") {
				iterator.remove();
			}

		}
//		System.out.println(li);
//		将中缀表达式转为后缀表达式
		List<String> list = mid2Last(li);
//		System.out.println(list);
//		使用后缀表达式计算：数字进栈，遇到操作符 弹出两个数字，将结果进栈
//		首先将后缀表达式的list 转为int 类型 方便后续计算，操作符char类型也可以直接当作int操作
		List<Integer> list2 = String2Integer(list);
//		System.out.println(list2);
		System.out.printf("%s=%d\n",str,nPoland(list2));
	}
	
	
	public static int nPoland(List<Integer> list) {
//		使用后缀表达式计算：数字进栈，遇到操作符 弹出两个数字，将结果进栈
		Stack<Integer> stack=new Stack<>();
		for(int item:list) {
//			判断是否为操作符
			if(isOption(item)&&stack.size()>0) {
				int num1 = stack.pop();
				int num2 = stack.pop();
				int res=result(num1,num2,item);
				stack.push(res);
			}else {
				stack.push(item);
			}
			
		}
		return stack.pop();
		
	}
	/**
	 * 判断是否为操作符
	 * @param li
	 * @return
	 */
	public static boolean isOption(int li) {
		return li=='+'||li=='-'||li=='*'||li=='/';
	}
	/**
	 * op运算
	 * @param num1
	 * @param num2
	 * @param op
	 * @return
	 */
	public static int result(int num1,int num2,int op) {
		int res=0;
		switch(op) {
		case '+':res=num1+num2;break;
		case '-':res=num2-num1;break;
		case '*':res=num2*num1;break;
		case '/':res=num2/num1;break;
		default:break;
		}
		return res;
	}
	
	/**
	 * 遍历集合，将元素转为int 类型,java中int 类型和char类型可以混用
	 * @param list
	 * @return
	 */
	public static List<Integer> String2Integer(List<String> list){

		List<Integer> list2=new ArrayList<>();
		for(String li:list) {
			int i=0;
			if(li.equals("+")||li.equals("-")||li.equals("*")||li.equals("/")) {
				i=li.charAt(0);
			}else {
				i=Integer.parseInt(li);
			}
			list2.add(i);
		}
		return list2;
	}
	
	
	
	
	
	
	/**
	 * 具体步骤如下: 初始化两个栈：运算符栈s1和储存中间结果的栈s2； 从左至右扫描中缀表达式； 遇到操作数时，将其压s2；
	 * 遇到运算符时，比较其与s1栈顶运算符的优先级： 如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
	 * 否则，若优先级比栈顶运算符的高，也将运算符压入s1； 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
	 * 遇到括号时： (1) 如果是左括号“(”，则直接压入s1 (2)
	 * 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃 重复步骤2至5，直到表达式的最右边
	 * 将s1中剩余的运算符依次弹出并压入s2 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
	 * 
	 * 由于最后需要逆序输出：这里S2直接用list代替
	 * @param li
	 * @return
	 */
	public static List<String> mid2Last(List<String> li){
		Stack<String> stack=new Stack<>();
		List<String> list=new ArrayList<>();
		for(String item:li) {
//			遇到操作数时，将其压s2；
			if(item.matches("\\d+")) {
				list.add(item);
			}else {
//				遇到运算符时，比较其与s1栈顶运算符的优先级	
//				如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
//				否则，若优先级比栈顶运算符的高，也将运算符压入s1； 否则，将s1栈顶的运算符弹出并压入到s2中
				if(stack.size()==0||item.equals("(")) {
					stack.push(item);
				}else if(item.equals(")")) {//遇到)时候：开始弹栈，直到遇到(,最后将(也弹出
					while(!stack.peek().equals("(")) {
						list.add(stack.pop());
					}
					stack.pop();
				}else {//遇到运算符，开始比较运算符：如果 当前的运算符 大于 栈顶的运算符则 进栈，否则将栈中运算符弹出，再进栈
					if(opPriperty(item)>opPriperty(stack.peek())) {
						stack.push(item);
					}else {
						list.add(stack.pop());
						stack.push(item);
					}
				}
				
			}
		}
//		将s1中剩余的运算符依次弹出并压入s2 依次弹出s2中的元素并输出
		while(stack.size()>0) {
			list.add(stack.pop());
		}
		return list;
	}
	/**
	 * 用来做运算符比较
	 * @param op
	 * @return
	 */
	public static int opPriperty(String op) {
		if(op.equals("+")||op.equals("-")) {
			return 0;
		}else if(op.equals("*")||op.equals("/")) {
			return 1;
		}else {
			return -1;
		}
		
	}
	public static List<String> numsMerge(String str){
//		String s="723+5*7890+123";
		char[] chs=str.toCharArray();
		List<String> list=new ArrayList<>();
		String ss="";
		for(int i=0;i<chs.length;i++) {
			if(chs[i]>='0'&&chs[i]<='9') {
				ss+=chs[i];
			}
			else {
				list.add(ss);
//				System.out.println(chs[i]);
				list.add(String.valueOf(chs[i]));
				ss="";
			}
			
		}
//		System.out.println(ss);
		list.add(ss);
//		System.out.println(list);
		return list;
	}

}