用java解析字符串，如字符串"(1+2⼀5)*3"当成是数值表达式，进行计算出结果来。

如果你懂Pascal语言,可以到http://user.qzone.qq.com/413405663/blog/1259328420看看

import java.io.*;
import java.util.*;
class BinaryTree{
BinaryTree left=null;
BinaryTree right=null;
char data=0;
}
public class Calculator{
String porder="";
public void postorder(BinaryTree bt){
//递归后序遍历二叉树
if(bt!=null){
postorder(bt.left);
postorder(bt.right);
porder+=bt.data;
}
}
public int calc(String s){
//计算后缀表达式的值
int i=0,len=0,a=0,b=0;
Stack stack=new Stack();
len=s.length();
for(;i char c=s.charAt(i);
switch(c){
case '+':
a=(int)stack.pop();
b=(int)stack.pop();
stack.push(a+b);
break;
case '-':
b=(int)stack.pop();
a=(int)stack.pop();
stack.push(a-b);
break;
case '*':
a=(int)stack.pop();
b=(int)stack.pop();
stack.push(a*b);
break;
case '/':
b=(int)stack.pop();
a=(int)stack.pop();
stack.push((int)a/b);
break;
default:
//该字符是数字
stack.push(c-'0');
}
}
return stack.pop();
}
public BinaryTree create(String s){
//构造二叉树结点(递归)
int i=0,pos=0,len=0;
String l="",r="";
BinaryTree node=new BinaryTree();
len=s.length();
if(len==0) return null;
if(len==1){
//递归边界
node.data=s.charAt(0);
return node;
}
//去括号
while((pos=s.indexOf(")"))!=-1){
i=pos;
while((s.charAt(i)!='(')&&(i>0)) i--;
String sub=s.substring(i+1,pos);//括号中的表达式
porder="";
postorder(create(sub));//得到后缀表达式
int sum=calc(porder);//计算后缀表达式的值,替换原来括号中的表达式
s=s.substring(0,i)+String.valueOf(sum)+s.substring(pos+1);
len=s.length();//重新计算s的长度
}
//从后往前扫描得到的第一个优先级最低的运算符号的位置
pos=-1;
for(i=len-1;i>0;i--){
char c=s.charAt(i);
if((c=='+')||(c=='-')){
pos=i;
break;
}
else if(((c=='*')||(c=='/'))&&(pos==-1)) pos=i;
}
//在pos位置将s分为左右两部分,递归构造左右两个部分的二叉树
l=s.substring(0,pos);
r=s.substring(pos+1);
node.data=s.charAt(pos);
node.left=create(l);
node.right=create(r);
return node;
}
public static void main(String args[]) throws Exception{
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
String s=reader.readLine();
Calculator c=new Calculator();
BinaryTree bt=c.create(s);
c.postorder(bt);
System.out.println(c.calc(c.porder));
}
}

数值表达式的解析式有几种不同的算法，如可以用栈，二叉树也可以实现。现在几乎任意一本数据结构书都会涉及到相关的内容。如用栈，算法的基本思想是这样的。
先从原来的中缀表达式转换成后缀表达式，然后再计算后缀表达式的值。如上式转换成中缀表达式好像是这样的： 3 1 2 5/+*，然后计算后缀表达式就比较容易了

解析字符串，是编程最基本的工作，简单的字符串一般都有固定的分隔符如CSV, 直接用分隔符split就好了。复杂一点的可以用正则表达式分组来做。

分组是正则表达式的一个重要特性，在脚本语言里例如perl应用非常广泛。 其实Java也提供了正则表达式的分组特性。简单的例子，如果我们要解析 年月日 ，格式如下 %Y/y %M/m %D/d 而且我们要求， 其中每一项必须按次序出现。下面是代码实现

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test {
public static void main(String[] args) {
tests("2Y3M1D");
}

private static void tests(String test) {
String regex = "^((\\d+)[Yy])?((\\d+)[Mm])?((\\d+)[Dd])?$";
//正则式
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(test);
//使用正则式匹配字符串
boolean ret = matcher.find();
//查找上一个匹配式不是存在

if (ret) {
final int y = 2;
final int m = 4;
final int d = 6;

//查找相应的分组，也就是()对应的字符串
//分组0是整个字符串
//1 ((\\d+)[Yy])对应内容
//2 (\\d+)对应内容
//....
String Year = matcher.group(y);
String month = matcher.group(m);
String date = matcher.group(d);
System.out.println("Year:" + Year + " Month:" + month + " Date"
+ date);
}
}

}

import java.io.*;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
public class Main
{
    public static void main(String[] args) throws Exception
    {
        String expr = "(1+2/5)*3";
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("js");
        Object result = engine.eval(expr);
        System.out.println(result);
    }
}

用数据结构中的栈来解决
操作数放到一个操作数栈，操作符放到一个操作栈中
具体看下严蔚敏的数据结构，好像讲堆栈的那章