初学java,编写了一个计算24点的程序，时间有限，有些粗糙，不过可以使用。
 
//-------------Cal24.java---------------
//计算24点程序
//作者：徒步天下(hiker2008.blog.51cto.com)
//
//运行格式： java Cal24 abcd
//abcd为四个1-9数字
//
//输出为结果等于24的算式，及个数
 
import java.util.*;
public class Cal24 {
 String[] op;
 Set num = new HashSet();
 
 public static void main(String[] args) {
  Cal24 cal24;
  if (args.length<1) {
   System.out.println("Usage Cal24 abcd");
   return;
  }
  cal24 = new Cal24(args[0]);
  cal24.pEx();
 }
 
 //初始化数字组合和符号组合
 Cal24(String inputnum) {
  
  //生成所输入abcd四个数字的全排列（不可重复使用，如aaaa），去掉重复的，保存在 num 字符串集合
  for (int i=0;i<4;i++) {
   for (int j=0;j<4;j++) {
    for (int k=0;k<4;k++) {
     if (i==j || i==k || k==j)   //去掉重复使用同一数字的情况
      continue;
     int z=6-i-j-k;     //计算出剩下的第四个数。 i+j+k+z=6
     num.add(new String(inputnum.substring(i,i+1)+inputnum.substring(j,j+1)
       +inputnum.substring(k,k+1)+inputnum.substring(z,z+1)));
    }
   }
  }
  // 生成＋－×／符号的全排列（可重复使用,如+++），保存在 op 字符串数组
  op = new String[64];
  String t="+-*/";
  for (int i=0;i<4;i++) {
   for (int j=0;j<4;j++) {
    for (int k=0;k<4;k++) {
     int z=i*16+j*4+k;
     op[z]=new String(t.substring(i,i+1)+t.substring(j,j+1)+t.substring(k,k+1));
    }
   }
  }
 }
 
 // 查找等于24的算式
 void pEx() {
  Iterator i=num.iterator();
  
  while (i.hasNext()) {
   // 遍历每一个数字组合和每一个符号组合
   String testNum=(String)i.next();
   for (int j=0;j<64;j++)
    new CalAopBopCopD(testNum,op[j]); //计算五种不同顺序的值
  }
  
  //输出等于24的不同算式总数。
  System.out.println("Total found : "+CalAopBopCopD.getTotal());
 }
 
 //打印数字组合和符号组合，测试使用
 void printOp() {
  Iterator i=num.iterator();
  while (i.hasNext()) {
   System.out.print(i.next());
  }
  for (int j=0;j<64;j++) {
   System.out.println("op["+j+"]="+op[j]);
  }
 }
}
//生成 a op1 b op2 c op3 d的不同计算顺序的算式，打印计算结果等于24的算式并计数
class CalAopBopCopD {
 static int total=0;  //结果等于24的算式计数
 double a,b,c,d;   //四个操作数
 char op1,op2,op3;  //三个运算符号
 double z1,z2,z3;  //运算中间结果
 CalAopB t;    //计算 a op b 的对象
 
 //返回结果等于24的算式总数
 static int getTotal() {
  return total;
 }
 
 //根据数字组合和符号组合，转换成对象中类型，依次生成并计算不同顺序的算式
 CalAopBopCopD(String n,String o) {
  a = Double.parseDouble(n.substring(0,1));
  b = Double.parseDouble(n.substring(1,2));
  c = Double.parseDouble(n.substring(2,3));
  d = Double.parseDouble(n.substring(3,4));
  op1 = o.charAt(0);
  op2 = o.charAt(1);
  op3 = o.charAt(2);
  
  //依次生成并计算不同顺序的算式
  printEx1();
  printEx2();
  printEx3();
  printEx4();
  printEx5();
 }
 
 
 void printEx1() {
  //算式顺序： (a op1 b) op2 (c op3 d)
  t=new CalAopB(a,op1,b);
  if (t.getErr())
   return;
  else
   z1=t.getResult();
  t=new CalAopB(c,op3,d);
  if (t.getErr())
   return;
  else
   z2=t.getResult();
  t=new CalAopB(z1,op2,z2);
  if (t.getErr())
   return;
  else
   z3=t.getResult();
  if (Math.abs(z3-24.0) <0.0001) {
   System.out.println("No. "+(++total)+" : ( "+(int)a+" "+op1+" "+(int)b
     +" ) "+op2+" ( "+(int)c+" "+op3+" "+(int)d
     +" ) = 24");
  }
 }
 
 void printEx2() {
  //算式顺序： ((a op1 b) op2 c) op3 d
  t=new CalAopB(a,op1,b);
  if (t.getErr())
   return;
  else
   z1=t.getResult();
  t=new CalAopB(z1,op2,c);
  if (t.getErr())
   return;
  else
   z2=t.getResult();
  t=new CalAopB(z2,op3,d);
  if (t.getErr())
   return;
  else
   z3=t.getResult();
  if (Math.abs(z3-24.0) <0.0001) {
   System.out.println("No. "+(++total)+" : ( ( "+(int)a+" "+op1+" "+(int)b
     +" ) "+op2+" "+(int)c+" ) "+" "+op3+" "+(int)d
     +" = 24");
  }
 }
 
 void printEx3() {
  //算式顺序： ( a op1 ( b op2 c)) op3 d
  t=new CalAopB(b,op2,c);
  if (t.getErr())
   return;
  else
   z1=t.getResult();
  t=new CalAopB(a,op1,z1);
  if (t.getErr())
   return;
  else
   z2=t.getResult();
  t=new CalAopB(z2,op3,d);
  if (t.getErr())
   return;
  else
   z3=t.getResult();
  if (Math.abs(z3-24.0) <0.0001) {
   System.out.println("No. "+(++total)+" : ( "+(int)a+" "+op1+" ( "+(int)b
     +" "+op2+" "+(int)c+" ) ) "+op3+" "+(int)d
     +" = 24");
  }
 }
 
 void printEx4() {
  //算式顺序： a op1 (( b op2 c) op3 d )
  t=new CalAopB(b,op2,c);
  if (t.getErr())
   return;
  else
   z1=t.getResult();
  t=new CalAopB(z1,op3,d);
  if (t.getErr())
   return;
  else
   z2=t.getResult();
  t=new CalAopB(a,op1,z2);
  if (t.getErr())
   return;
  else
   z3=t.getResult();
  if (Math.abs(z3-24.0) <0.0001) {
   System.out.println("No. "+(++total)+" : "+(int)a+" "+op1+" ( ( "+(int)b
     +" "+op2+" "+(int)c+" ) "+op3+" "+(int)d
     +" ) = 24");
  }
 }
 
 void printEx5() {
  //算式顺序： a op1 ( b op2 ( c op3 d ))
  t=new CalAopB(c,op3,d);
  if (t.getErr())
   return;
  else
   z1=t.getResult();
  t=new CalAopB(b,op2,z1);
  if (t.getErr())
   return;
  else
   z2=t.getResult();
  t=new CalAopB(a,op1,z2);
  if (t.getErr())
   return;
  else
   z3=t.getResult();
  if (Math.abs(z3-24.0) <0.0001) {
   System.out.println("No. "+(++total)+" : "+(int)a+" "+op1+" ( "+(int)b
     +" "+op2+" ( "+(int)c+" "+op3+" "+(int)d
     +" ) ) = 24");
  }
 }
 
}
//计算 a op b 的值
//a,b是两个double类型，op为'+','-','*','/'四个符号中的一个。
class CalAopB {
 double a,b;  //两个操作数
 char op;  //运算符号
 int err=0;  //运算出错，则<0；正确，则为0
 double result; //运算结果
 
 // 初始化对象
 CalAopB(double sa, char sop, double sb) {
  a= sa;
  b = sb;
  op = sop;
  String opstring="+-*/"; 
  if (opstring.indexOf(op)<0) {
   err= -1;
  } else {
   calResult();
  }
 }
 //计算结果
 void calResult() {
  switch(op) {
  case '/':
    if (Math.abs(b)<0.00001) {
     err = -2;
     break;
    }
    result = a/b;
    break;
  case '+':
    result = a+b;
    break;
  case '-':
    result = a-b;
    break;
  case '*':
    result = a*b;
    break;
  default:
    err=-3;
    break;
  }
 }
 
 //返回是否出错，出错为true,不出错为false
 boolean getErr() {
  if (err==0)
   return false;
  else
   return true;
 }
 
 //返回计算结果
 double getResult() {
  return result;
 }
}
//-------------end---------------