24点游戏

题目:

     用给定的四张扑克牌通过加减乘除组成数字24，共有三条生命，在一分钟的时间内完成操作，否则生命减一，答对后分数加十分，三条生命用完后，游戏结束并显示分数

解答过程:

利用中缀表达式转后缀表达式计算输入的结果

//得到运算符的优先级
	public int GetPriority(String sign) {
		switch(sign) {
		case "+":
		case "-": return 1;
		case "*":
		case "/": return 2;
		case "(":
		case ")": return 3;
		}
		return 0;
	}
	//将输入的整条字符串分解成字符数组
	public ArrayList<String> calStr(String s) {
		String[] calculator;
		ArrayList<String> mid=new ArrayList<>();
		calculator=s.split(" ");
		for(String cal:calculator) {
			mid.add(cal);
		}
		return mid;
	}
	//中缀表达式转后缀表达式
	public Stack<String> transform(ArrayList<String> mid) {
		Stack<String> operator=new Stack<>();
		Stack<String> last=new Stack<>();
		Iterator<String> inter=mid.iterator();
		while(inter.hasNext()) {
			String tem=inter.next();
			if(tem.equals("+")||tem.equals("-")||tem.equals("*")||tem.equals("/")) {
				if(operator.empty()||GetPriority(operator.peek())<GetPriority(tem)) {
					operator.push(tem);
				}
				else {			
					while(!operator.empty()&&GetPriority(operator.peek())>=GetPriority(tem)) {
						if(operator.peek()!="(") {
							last.push(operator.pop());
						}
						else break;
					}
					operator.push(tem);
				}
			}
			else if(tem.equals("(")){
				operator.push("(");
			}
			else if(tem.equals(")")){
				while(operator.peek()!=("(")){
					last.push(operator.pop());
				}
				operator.pop();
			}
			else if(Character.isDigit(tem.charAt(0))){
				last.push(tem);
			}
			else {}

		}
		while(!operator.empty()) {
			last.push(operator.pop());
		}
		return last;	
	}
	//计算输入表达式的最终结果
	public double calResult(Stack<String> last) {
		Stack<String> result=new Stack<>();
		Iterator<String> it=last.iterator();
		while(it.hasNext()) {
			String tem=it.next();
			if(Character.isDigit((tem.charAt(0)))) {
				result.push(tem);
			}
			if(tem.equals("+")||tem.equals("-")||tem.equals("*")||tem.equals("/")) {
				double a,b;
				b=Double.parseDouble(result.pop());
				a=Double.parseDouble(result.pop());
				String c=cal(tem,a, b)+"";
				result.push(c);
			}
		}
		return Double.parseDouble(result.pop());
	}

利用线程实现计时操作

	//新建一个时间线程
	class TimeThread extends Thread {
		@Override
		public void run() {
			try {
				Thread.sleep(10000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if(resultflag==0) {		
				threadflag=0;
				life--;
				System.out.println("时间到，挑战失败，您还有"+life+"次机会");
				this.interrupt();
			}
		}
	}
	//时间线程创建对象
	TimeThread newThread() {
		TimeThread timeThread=new TimeThread();	
		return timeThread;
	}

遇到的问题：

1. 堆栈的使用 Stack 直接定义堆对象 pop，peek，push ，empty等方法实现对堆栈的操作

 Stack<>  stack =new Stack<>();

也可以使用LinkedList模拟实现堆栈

LinkedList<> stack=new LinkedList<>();

2. 中缀表达式转后缀表达式的步骤

     遇到数字输出，遇到符号跟栈顶比较，如果本身优先级高则直接压栈，如果本身优先级低过一样，则将栈顶弹出输出后，继续与新的栈顶元素比较，知道符合直接压栈的条件，将元素压栈，如果遇到左括号直接压栈，遇到右括号将左括号之前的元素逐个弹出并输出
   

3. 线程与主线程之间的通信

     通过定义flag标识符来实现，标识符变为true，线程符合条件输出，否则不尽兴任何操作通过定义flag标识符来实现，标识符变为true，线程符合条件输出，否则不尽兴任何操作