一、前缀表达式

前缀表达式是一种没有括号的算术表达式，与中缀表达式不同的是，其将运算符写在前面，操作数写在后面。为纪念其发明者波兰数学家Jan Lukasiewicz，前缀表达式也称为“波兰式”。

例如，- 1 + 2 3，它等价于1-(2+3)。

二、中缀表达式

是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。

三、后缀表达式

逆波兰式，也叫后缀表达式（将运算符写在操作数之后）。

例如，1 2 3 + - ， 它等价于1-(2+3)。

对于人来说，中缀表达式是最清晰的。可在计算机看来逆波兰式是比较简单易懂的结构。因为计算机普遍采用的内存结构是栈式结构，它执行先进后出的顺序。

下图是给出一个表达式，使用逆波兰表示法的计算步骤：

下面实现一下，用逆波兰表达式实现一个简易的计算器。

需求如下：

• 输入一个逆波兰表达式（后缀表达式），使用栈，计算其结果。

• 支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。

思路分析：

新增知识点：

1. 通过正则表达式来判断匹配的是不是多位数。
   

\ \d 实际上是 \ d ，因为Java中 \ 是转义字符前导符，所以在字符串中书写 \ 必须得写成 \ \ 才能正确识别，所以正则表达式中的 \ d 就表示为 \ \ d 。

\ d表示匹配一个数字(0到9).

+表示1个或多个数字。

合起来，\d+ 就表示 匹配一个多位数。

Java API文档中，从String的match方法里找可以找到更多用法。

2. 分割字符串

 String[] split = suffixExpression.split(" ");
 //suffixExpression是一个字符串例如"34 4 + 5 × 6 -"
 //这行代码的作用是将这个字符串，以“ ”，即空格为分割符，对字符串进行分割
 

那么问题来了，分割完了放在哪儿呢？

答案是定义一个String 类型的集合 List 来存放。

Java集合类存放在java.util包中，是一个用来存放对象的容器。
　
1.集合 只能存放对象。比如你存入一个int型数据999 放入集合中，它会自动转换成Integer类后存入。

2.集合 存放的都是对象的引用，而非对象本身。所以我们称集合中的对象就是集合中对象的引用，对象本身还是放在堆内存中。
3.集合 可以存放不同类型、不限数量的数据类型。

		List<String> list = new ArrayList<String>();// 创建空的list，存放下面通过for 循环，分割之后的结果。
		// 分割完后就成为一个数组了，每循环一次就取出一个元素

下面这个方法，用来返回分割成功之后的集合。

	public static List<String> getListString(String suffixExpression) {
    
    
		// 将suffixExpression 分割
		String[] split = suffixExpression.split(" ");// 以空格为标志，对字符串分割
		List<String> list = new ArrayList<String>();// 创建空的list，存放下面通过for 循环，分割之后的结果。
		// 分割完后就成为一个数组了，每循环一次就取出一个元素
		for (String ele : split) {
    
    
			list.add(ele);
		}
		return list;
	}

例如：
待分割字符串为：“4 5 × 8 - 60 + 8 2 / +”

测试一下，

结果为：

3. 创建一个存放String 类型的栈：
   
   由于栈是存放String 类型数据的，所以入栈前就需要这样的一个转换类型的小操作，妙啊。
   

4. 将引用类型转换成整数类型并返回。（这里返回的是计算的结果）
   

完整代码

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
//这里导List包时，有两个选项,这个java.awt.List;导入会报错。

public class PolandNotation {
    
    

	public static void main(String[] args) {
    
    
		// 先定义一个逆波兰表达式 (3+4)×5-6 => 3 4 + 5 × 6 - => 29
		// 4×5-8+60+8/2 => 4 5 × 8 - 60 + 8 2 / +
		// 为了方便，逆波兰表达式的数字 和符号用括号隔开
		// String suffixExpression = "34 4 + 5 × 6 -";//184
		String suffixExpression = "4 5 × 8 - 60 + 8 2 / +";// 76

		// 思路
		// 1、先将suffixExpression 放到ArrayList中
		// 2、将ArrayList 传递给一个方法，遍历ArrayList 配合栈完成计算

		List<String> listString = getListString(suffixExpression);// Alt+Shift+L
		System.out.println("listString=" + listString);// 将后缀表达式分割后的结果
		int res = calculate(listString);
		System.out.println("计算的结果是=" + res);
	}

	// 一个逆波兰表达式，依次将数据和运算符 放入到ArrayList 中
	public static List<String> getListString(String suffixExpression) {
    
    
		// 将suffixExpression 分割
		String[] split = suffixExpression.split(" ");// 以空格为标志，对字符串分割
		List<String> list = new ArrayList<String>();// 创建空的list，存放下面通过for 循环，分割之后的结果。
		// 分割完后就成为一个数组了，每循环一次就取出一个元素
		for (String ele : split) {
    
    
			list.add(ele);
		}
		return list;
	}

	public static int calculate(List<String> ls) {
    
    
		// 创建栈，只需要一个栈即可
		Stack<String> stack = new Stack<String>();
		// 遍历 ls
		for (String item : ls) {
    
    
			// 这里使用 正则表达式 来取出数
			if (item.matches("\\d+")) {
    
    // 匹配的是多位数
				// 入栈
				stack.push(item);
			} else {
    
    
				// pop 出两个数，并运算，再入栈
				int num2 = Integer.parseInt(stack.pop());// 将字符串类型的数字，转成int 类型的数
				int num1 = Integer.parseInt(stack.pop());
				int res = 0;
				if (item.equals("+")) {
    
    
					res = num1 + num2;
				} else if (item.equals("-")) {
    
    
					res = num1 - num2;
				} else if (item.equals("×")) {
    
    
					res = num1 * num2;
				} else if (item.equals("/")) {
    
    
					res = num1 / num2;
				} else {
    
    
					throw new RuntimeException("运算符有误");
				}
				// 把res 入栈
				stack.push("" + res);// 把整数转为字符串
			}
		}
		// 最后留在stack 中的数据就是运算结果
		return Integer.parseInt(stack.pop());
	}

}