float Compute(char* str)
// 计算由str字符串所表示的后缀表达式的值，
// 表达式要以'@'字符结束。
...{
Stack S; // 用S栈存储操作数和中间计算结果
InitStack(S); // 初始化栈
istrstream ins(str); // 把str定义为输入字符串流对象ins
char ch; // 用于输入字符
float x; // 用于输入浮点数
ins>>ch; // 从ins流对象(即str字符串)中顺序读入一个字符
while(ch!='@')
...{ // 扫描每一个字符并进行相应处理
switch(ch)
...{
case '+':
x=Pop(S)+Pop(S); 
break;
case '-':
x=Pop(S); // Pop(S)弹出减数
x=Pop(S)-x; // Pop(S)弹出的是被减数
break;
case '*':
x=Pop(S)*Pop(S);
break;
case '/':
x=Pop(S); // Pop(S)弹出除数
if(x!=0.0)
x=Pop(S)/x; // Pop(S)弹出的是被除数
else ...{ // 除数为0时终止运行
cerr<<"Divide by 0!"< exit(1);
}
break;
default: // 读入的必为一个浮点数的最高位数字
ins.putback(ch); // 把它重新回送到输入流中
ins>>x; // 从字符串输入流中读入一个浮点数
}
Push(S,x); // 把读入的一个浮点数或进行相应运算
// 的结果压入到S栈中
ins>>ch; // 输入下一个字符，以便进行下一轮循环处理
}
if(!StackEmpty(S)) 
...{ // 若栈中仅有一个元素，则它是后缀表达式的值，否则为出错
x=Pop(S);
if(StackEmpty(S)) 
return x; 
else ...{
cerr<<"expression error!"< exit(1);
}
}
else ...{ // 若最后栈为空，则终止运行
cerr<<"Stack is empty!"< exit(1);
}
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1423390

把运算符放在参与运算的两个操作数后面的算术表达式称为后缀表达式。
例如，对于下列各中缀表达式：
(1)3/5+8
(2)18-9*(4+3)
对应的后缀表达式为：
(1)3 5 / 8 +
(2)18 9 4 3 + * -
转换规则:把每个运算符都移到它的两个操作数的后面,然后删除掉所有的括号即可.

    三 表达式的计算：

由于后缀表达式中没有括号，不需判别优先级，计算严格从左向右进行，故计算一个后缀表达式要比计算机一个中缀表达式简单得多。

　　将中缀表达式转换为后缀表达式的算法思想：
　　·当读到数字直接送至输出队列中
　　·当读到运算符t时，
　　　　　a.将栈中所有优先级高于或等于t的运算符弹出，送到输出队列中；
　　　　　b.t进栈
　　·读到左括号时总是将它压入栈中
　　·读到右括号时，将靠近栈顶的第一个左括号上面的运算符全部依次弹出，送至输出队列后，再丢弃左括号。

    中缀表达式全部读完后，若栈中仍有运算符，将其送到输出队列中

　　 运用后缀表达式进行计算的具体做法：
　　·建立一个栈S
　　·从左到右读后缀表达式，读到数字就将它转换为数值压入栈S中，读到运算符则从栈中依次弹出两个数分别到Y和X，然后以"X 运算符 Y"的形式计算机出结果，再压加栈S中
　　·如果后缀表达式未读完，就重复上面过程，最后输出栈顶的数值则为结束

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=619852

 
 private Map inParam;
 
 public MktLoadStoredProcedure(String storedProcedureName) {
  DataSource ds = (DataSource)SpringContextUtils.getInstance().getBean("dataSource");
  setDataSource(ds);
  setSql(storedProcedureName);
 }
 
 public RowMapper RouteRowMapper = new RowMapper(){
  public Object mapRow(ResultSet rs,int rowNum) throws SQLException{
   BidRouteInfo route = new BidRouteInfo();
   route.setBidHeaderId(rs.getString("BID_HEADER_ID"));
   route.setBidRouteInfoId(rs.getString("BID_ROUTE_INFO_ID"));
   route.setCreatedByUser(rs.getString("CREATED_BY_USER"));
   route.setCreatedDtmLoc(rs.getDate("CREATED_DTM_LOC"));
   route.setCreatedOffice(rs.getString("CREATED_OFFICE"));
   route.setCreatedTimeZone(rs.getString("CREATED_TIME_ZONE"));
   route.setDestCode(rs.getString("DEST_CODE"));
   route.setDestName(rs.getString("DEST_NAME"));
   route.setPodCode(rs.getString("POD_CODE"));
   route.setPodDestMode(rs.getString("POD_DEST_MODE"));
   route.setPodName(rs.getString("POD_NAME"));
   route.setPolCode(rs.getString("POL_CODE"));
   route.setPolName(rs.getString("POL_NAME"));
   route.setPorCode(rs.getString("POR_CODE"));
   route.setPorName(rs.getString("POR_NAME"));
   route.setPorPolMode(rs.getString("POR_POL_MODE"));
   route.setPorState(rs.getString("POR_STATE"));
   route.setPrincipalGroupCode(rs.getString("PRINCIPAL_GROUP_CODE"));
   route.setRecordVersion(rs.getLong("RECORD_VERSION"));
   route.setSeqNo(rs.getLong("SEQ_NO"));
   route.setServiceType(rs.getString("SERVICE_TYPE"));
   route.setStateCode(rs.getString("STATE_CODE"));
   route.setUpdatedByUser(rs.getString("UPDATED_BY_USER"));
   route.setUpdatedDtmLoc(rs.getDate("UPDATED_DTM_LOC"));
   route.setUpdatedOffice(rs.getString("UPDATED_OFFICE"));
   route.setUpdatedTimeZone(rs.getString("UPDATED_TIME_ZONE"));
   route.setRowStatus(BaseObject.ROWSTATUS_UNCHANGED);
   return route;
  }
 };
 
 public RowMapper FreightRowMapper = new RowMapper(){
  public Object mapRow(ResultSet rs,int rowNum) throws SQLException{
   BidFreightDetail freight = new BidFreightDetail();
   freight.setBidRouteInfoId(rs.getString("BID_ROUTE_INFO_ID"));
   freight.setBgColor(rs.getString("BG_COLOR"));
   freight.setBidFreightDetailId(rs.getString("BID_FREIGHT_DETAIL_ID"));
   freight.setChargeCode(rs.getString("CHARGE_CODE"));
   freight.setContainerType(rs.getString("CONTAINER_TYPE"));
   freight.setCreatedByUser(rs.getString("CREATED_BY_USER"));
   freight.setCreatedDtmLoc(rs.getDate("CREATED_DTM_LOC"));
   freight.setCreatedOffice(rs.getString("CREATED_OFFICE"));
   freight.setCreatedTimeZone(rs.getString("CREATED_TIME_ZONE"));
   freight.setPrincipalGroupCode(rs.getString("PRINCIPAL_GROUP_CODE"));
   freight.setRate(rs.getBigDecimal("RATE"));
   freight.setRecordVersion(rs.getLong("RECORD_VERSION"));
   freight.setUpdatedByUser(rs.getString("UPDATED_BY_USER"));
   freight.setUpdatedDtmLoc(rs.getDate("UPDATED_DTM_LOC"));
   freight.setUpdatedOffice(rs.getString("UPDATED_OFFICE"));
   freight.setUpdatedTimeZone(rs.getString("UPDATED_TIME_ZONE"));
   freight.setRowStatus(BaseObject.ROWSTATUS_UNCHANGED);
   return freight;
  }
 };
 //spring版本从1.2更新到2.0-rc3
// private RowMapperResultReader callback = new RowMapperResultReader(rowMapper){
//  public void processRow(ResultSet rs) throws SQLException{
//   int count = rs.getMetaData().getColumnCount();
//   String[] header = new String[count];
//   for(int i=0;i<count;i++){
//    header[i] = rs.getMetaData().getColumnName(i+1);
//   }
//   do{
//     HashMap<String,String> row = new HashMap<String,String>();
//     for(int i=0;i<count;i++){
//      row.put(header[i],rs.getString(i+1));
//     }
//     rsList.add(row);
//   }while(rs.next());
//  }
// };
 
// private RowMapperResultSetExtractor callback = new RowMapperResultSetExtractor(RouteRowMapper){
//  public List extractData(ResultSet rs) throws SQLException{
//   int count = rs.getMetaData().getColumnCount();
//   String[] header = new String[count];
//   for(int i=0;i<count;i++){
//    header[i] = rs.getMetaData().getColumnName(i+1);
//   }
//   while(rs.next()){
//     HashMap<String,String> row = new HashMap<String,String>();
//     for(int i=0;i<count;i++){
//      row.put(header[i],rs.getString(i+1));
//     }
//     rsList.add(row);
//   }
//   return rsList;
//  }
// };
 
 public Map execute(){
  compile();
  if(inParam == null){
   return execute();
  }
  return execute(this.inParam);
 }

 public void setOutParameter(String column,int type,RowMapper rowMapper){
  declareParameter(new SqlOutParameter(column,type,rowMapper));
 }
 
 public void setParameter(String column,int type){
  declareParameter(new SqlParameter(column,type));
 }
 public void setInParam(Map inParam){
  this.inParam = inParam;
 }
}

调用：

   LoadStoredProcedure sp = new LoadStoredProcedure("SP_MKT_LOAD_TEST");
  sp.setParameter("V_BID_HEADER_ID", Types.VARCHAR);
  sp.setOutParameter("ROUTECURSOR", OracleTypes.CURSOR,sp.RouteRowMapper);
  sp.setOutParameter("FRIGHTCURSOR", OracleTypes.CURSOR,sp.FreightRowMapper);
  
  Map<String,String> mapValue = new HashMap<String,String>(1);
  mapValue.put("V_BID_HEADER_ID", bidHeaderId);
  sp.setInParam(mapValue);
  Map map = sp.execute();

List freightDetails = (List)map.get("FRIGHTCURSOR");
  List routeInfos = (List)map.get("ROUTECURSOR");
具体参考：

http://www.springframework.org/docs/reference/jdbc.html

    今天，来谈喝咖啡吗？当然不是，我们要看看咖啡到底该怎么喝，正如学 J2EE 一样。

太浓了吧

否則怎会苦的说不出话

每次都一个人在自问自答

我们的爱到底还在吗

    第一次，听到这段台词，您呢？听过没有，这可是我偶像唱的（张学友新专辑，《他在那里》中的，咖啡，建议听听，很不错。他的歌是流行，但又非流行）。

Java ，我来谈如何品她，可不是一件简单的事情，因为我喝的也不多，你呢？但我在用心去品。我们学技术，可不要陷入一个怪圈，唯技术论，这样的话你可就错了。无论什么技术，都是为人类服务的，我们的目标是更好的生活，自然咖啡也少不了。所以，我们对待 Java 的态度一定要有理性，比如，蔡學鏞先生 (http://www.oreilly.com.tw/sleepless/index.htm ) 都谦虚的说，他的 Java 功底是 Lots of API 。所以，心态要放平和，可不要有宗教式的仰慕（本人也是很喜欢 Java 的）。

初次接触 Java ，大家一定会被 Java 中大量的术语，新名词吓了一大跳。打开 The Source for Java Technology （ http://java.sun.com ） , 点击进入 http://java.sun.com/j2se/ ， Java 2 出来了，这可是热气腾腾的，很够味。下载一个 JavaTM 2 Platform, Standard Edition (J2SETM) ，网址 http://java.sun.com/j2se/downloads.html 。安装在一个没有空格的目录下。比如，俄 E:\j2sdk1.4.x 下。安装完后，您现在所需要的做的就是三件事情。第一，设置环境变量， set JAVA_HOME = E:\j2sdk1.4.x ，其次再设一个环境变量， set classpath = .; ，最后还需 set path = %JAVA_HOME%\bin 。这样就完成了 J2SE 的安装。安装完后，大家可以去 E:\j2sdk1.4.0\demo 运行 J2SE 带的 Demos 看看。哈哈，好漂亮。 E:\j2sdk1.4.0\demo\jfc\Java2D ，这个例子您看过没有，特别好看。好是羡慕。我自己也想写这么漂亮的程序。怎么办？？？？

http://java.sun.com/docs/books/tutorial/ , 这个地方可是您的切入点。我英文不怎么样，怎么办？其实技术领域的英文，你刚开始看的时候会有这样的想法，但时间长了，只要你可以坚持，慢慢的你就会发现，原来英文表达技术内涵特别贴切，不相信，你就看吧。。。：）

当然，做什么东西都得有工具。木匠有自己的一套工具。 Brood ，我们也得有自己的一些好工具。个人认为，这三件宝贝缺一不可。第一件， Java 2 SDK, Standard Edition, Documentation ， http://java.sun.com/j2se/1.4.1/docs/index.html 。这就是您的圣经，可要经常看看，不会的、会的，要经常参考，这可使你的功力大增，可要坚持哦，不要因为是一时的热情。第二件，就是，《 Thinking in Java 》， http://64.78.49.204/TIJ3.zip 有最新版（第三版）下载，其中讲述的 J2SE 1.4.0 。其中，第二版的中文翻译（由侯捷翻译的，一定不要错过！）， http://www.china-pub.com/computers/common/info.asp?id=7241 ，如果说第一件宝贝是圣经，那么这本就是玄学。这可是大家能修炼到的高境界的入门读物，一定比漫画书好看。那么，第三件是什么呢？那就是你自己，一定要多思考、多练、多写程序。你可以主宰一切，但除了你自己。

刚开始工具的选择，这个因人而异。我喜欢用大家伙，比如 JBuilder 、 Together 、 Eclipse 、 JDeveloper 、 ……. 。当然，你可以用 JCreator ，也挺不错的。大的工具可以加快你的功效，但前提是你对 Java 本身有良好的操控能力。

哦，轻松一下。

已经淡了吧

多放些糖也很难有变化

不如喝完这杯就各自回家

別坐在对面欣賞我的掙扎

其实，甜咖啡也挺不错的。看你喜不喜欢喝了。在这里说几句题外话，那就是计算机图书。其实，书，无论写得好与坏，都值得一看。但前提是你不会被他给误导。（如果，你第一次把我骗了，你就是很卑鄙；如果再次被你骗，说明我很无耻！：），这句话不是我说的）每本书都能反映作者的某种思想。所以多看书，还是不错的。这个时候肯定有人会问，看完后，隔上一段时间又忘得差不多了。其实这个很正常，关键看你是否坚持。

好了， J2SE 就谈到这里。有了相当的功底后，我们来啃另一快大石头， J2EE 。

J2EE ，现在可以说，是一个使自己身价抬高的绝佳途径。但看到那么多概念，术语，名词，算了，还是不学得好。我想我们都有这种想法。其实换一种角度，来看，不如 VB,Delphi 上手快。但有一点， J2EE 的体系特别清晰。由于 http://www.jcp.org , 操控了 Java 的命脉，所以你一定要知道这个地方。好了，首先去 http://java.sun.com/j2ee/download.html ， 下载一个 Sun 的参考实现版本 JavaTM 2 Platform, Enterprise Edition (J2EETM) 。安装完后，你可以参考安装目录 \doc 中配置相应的参数。好了，然后，去 http://java.sun.com/j2ee/tutorial/1_3-fcs/ 看看，当然，事务都是相通的。学 J2SE 中类似的过程在这里也可以拿过来。首先，给你 3 件宝刀。第一件， http://jcp.org/en/jsr/stage?listBy=final 下载 J2EE Specification ，这个规范可要经常看。这就是您的老师，什么时候都是。第二件宝贝您可一定不要错过， http://www2.theserverside.com/resources/index.jsp 这里很不错。第三件，可以去 http://java.sun.com/blueprints/ 看看 Petstore （至于其源代码是否值得研究，个人认为不值得，有这么多时间，不如去研究 JBoss ！）。或者说，换一种角度，您可以去 http://otn.oracle.com/sample_code/tutorials/fbs/fbstoc.htm 看看，看完后，你应该不会骂我的。

等您有了一定的 J2EE 功底后，你可以开始走向更高的地方，首先看段台词先。

一场失敗的爱情像个笑话

热得时后心乱如麻

冷了以后看见自己够傻

人怎么会如此容易无法自拔

其实，在 J2EE 中，重要的不是各个技术本身（ EJB, 比 COM 好学！！！您认为呢？），重要的是 J2EE 设计模式的合理运用。那么，其中，有三个东西值得您去关注。一个，在这个过程中，一定要把 J2EE 的体系结构弄得很清楚。二个， EJB 技术，这可是含金量很大的地方。第三，一定要关注常见的 Java Open Source 。。。这个都不知道的话，说明您还没有对 J2EE 有很好的认识。其中，有一些较好的资源， http://gceclub.sun.com.cn/experttalk/oct15.html 这可是一流的 Caffee!!! http://www2.theserverside.com/home/index.jsp 高手一定要去的地方。

慢慢的，您要形成善于、喜欢关注业界动态的习惯！！这种沉淀可是无价的。没有时间、精力的付出，你对业界是不会有很好的、很深的认识。

一句话，学习 J2EE ，一定要有宏观的把握，具体技术的深入细节需要我们在课题中慢慢领悟，这也不是看几本书所能掌握的，贵在坚持，但一定要注意方法。

一场无味的爱情像个谎话

甜的时后只相信它

苦了以后每一句都可怕

人怎么会如此容易了无牽掛

有了前面这些东东，我们可以开始研究某一个 J2EE 应用服务器。比如， JBoss, WebLogic 。首先学会熟练使用，慢慢的深入到具体的细节，比如 JMX 技术。因 J2EE 应用服务器集成、实现了规范中的所有技术，所以这些是很不错的思路。

Web Services 技术，可以说 J2EE 平台生来就有这种驾驭 Web Services 的能力。为什么这么说呢？ Web Services 技术，要是没有 XML 技术为先遣部队，我想 Web Services 业不会有今天。微软也不会把 Web Services 称之为， XML Web Services 技术。 XML 技术对数据提供了便利、 Java 对平台提供了便利。其结合的结果可想而知。即使没有“孤独求败”那么厉害，我想也会有“不败孤独”那么好。有些公司很会做技术，有些公司很会做市场。但大家的眼光是雪亮的，我们也没有必要说什么技术是万能的，没有万能的技术，关键看应用，是否能很好的解决实际问题。

说白了， Web Services 中其实没多少新东西，但这种体系结构需要您有很好的把握，然后深入技术细则。

这些，都是我的个人观点，希望看完后，有不对的地方，批评指正！！

也欢迎访问我的个人专栏。（也欢迎大家写信和我交流，交个朋友也可以！）

http://www.csdn.net/develop/author/netauthor/worldheart/

您开始喝咖啡没有？要不，给你来一杯，不要噎到了，要慢慢品，。。。。。

垃圾收集器的作用

　　虽然垃圾收集器处理了大多数内存管理问题，从而使编程人员的生活变得更轻 松了，但是编程人员还是可能犯错而导致出现内存问题。简单地说，GC循环地跟踪所有来自“根”对象（堆栈对象、静态对象、JNI句柄指向的对象，诸如此 类）的引用，并将所有它所能到达的对象标记为活动的。程序只可以操纵这些对象；其他的对象都被删除了。因为GC使程序不可能到达已被删除的对象，这么做就 是安全的。

　　虽然内存管理可以说是自动化的，但是这并不能使编程人员免受思考内存管理问题之苦。例如，分配（以及释放）内存总会 有开销，虽然这种开销对编程人员来说是不可见的。创建了太多对象的程序将会比完成同样的功能而创建的对象却比较少的程序更慢一些（在其他条件相同的情况 下）。

　　而且，与本文更为密切相关的是，如果忘记“释放”先前分配的内存，就可能造成内存泄漏。如果程序保留对永远不再使用的对 象的引用，这些对象将会占用并耗尽内存，这是因为自动化的垃圾收集器无法证明这些对象将不再使用。正如我们先前所说的，如果存在一个对对象的引用，对象就 被定义为活动的，因此不能删除。为了确保能回收对象占用的内存，编程人员必须确保该对象不能到达。这通常是通过将对象字段设置为null或者从集合 (collection)中移除对象而完成的。但是，注意，当局部变量不再使用时，没有必要将其显式地设置为null。对这些变量的引用将随着方法的退出 而自动清除。

　　概括地说，这就是内存托管语言中的内存泄漏产生的主要原因：保留下来却永远不再使用的对象引用。

典型泄漏

　　既然我们知道了在Java中确实有可能发生内存泄漏，就让我们来看一些典型的内存泄漏及其原因。

全局集合

　　在大的应用程序中有某种全局的数据储存库是很常见的，例如一个JNDI树或一个会话表。在这些情况下，必须注意管理储存库的大小。必须有某种机制从储存库中移除不再需要的数据。

　　这可能有多种方法，但是最常见的一种是周期性运行的某种清除任务。该任务将验证储存库中的数据，并移除任何不再需要的数据。

　　另一种管理储存库的方法是使用反向链接(referrer)计数。然后集合负责统计集合中每个入口的反向链接的数目。这要求反向链接告诉集合何时会退出入口。当反向链接数目为零时，该元素就可以从集合中移除了。

缓存

　　缓存是一种数据结构，用于快速查找已经执行的操作的结果。因此，如果一个操作执行起来很慢，对于常用的输入数据，就可以将操作的结果缓存，并在下次调用该操作时使用缓存的数据。

　　缓存通常都是以动态方式实现的，其中新的结果是在执行时添加到缓存中的。典型的算法是：

检查结果是否在缓存中，如果在，就返回结果。
如果结果不在缓存中，就进行计算。
将计算出来的结果添加到缓存中，以便以后对该操作的调用可以使用。
　　该算法的问题（或者说是潜在的内存泄漏）出在最后一步。如果调用该操作时有相当多的不同输入，就将有相当多的结果存储在缓存中。很明显这不是正确的方法。

　　为了预防这种具有潜在破坏性的设计，程序必须确保对于缓存所使用的内存容量有一个上限。因此，更好的算法是：

检查结果是否在缓存中，如果在，就返回结果。
如果结果不在缓存中，就进行计算。
如果缓存所占的空间过大，就移除缓存最久的结果。
将计算出来的结果添加到缓存中，以便以后对该操作的调用可以使用。
　　通过始终移除缓存最久的结果，我们实际上进行了这样的假设：在将来，比起缓存最久的数据，最近输入的数据更有可能用到。这通常是一个不错的假设。

　　新算法将确保缓存的容量处于预定义的内存范围之内。确切的范围可能很难计算，因为缓存中的对象在不断变化，而且它们的引用包罗万象。为缓存设置正确的大小是一项非常复杂的任务，需要将所使用的内存容量与检索数据的速度加以平衡。

　　解决这个问题的另一种方法是使用java.lang.ref.SoftReference类跟踪缓存中的对象。这种方法保证这些引用能够被移除，如果虚拟机的内存用尽而需要更多堆的话。

ClassLoader

　 　Java ClassLoader结构的使用为内存泄漏提供了许多可乘之机。正是该结构本身的复杂性使ClassLoader在内存泄漏方面存在如此多的问题。 ClassLoader的特别之处在于它不仅涉及“常规”的对象引用，还涉及元对象引用，比如：字段、方法和类。这意味着只要有对字段、方法、类或 ClassLoader的对象的引用，ClassLoader就会驻留在JVM中。因为ClassLoader本身可以关联许多类及其静态字段，所以就有 许多内存被泄漏了。

确定泄漏的位置

　　通常发生内存泄漏的第一个迹象是：在应用程序中出现了 OutOfMemoryError。这通常发生在您最不愿意它发生的生产环境中，此时几乎不能进行调试。有可能是因为测试环境运行应用程序的方式与生产系 统不完全相同，因而导致泄漏只出现在生产中。在这种情况下，需要使用一些开销较低的工具来监控和查找内存泄漏。还需要能够无需重启系统或修改代码就可以将 这些工具连接到正在运行的系统上。可能最重要的是，当进行分析时，需要能够断开工具而保持系统不受干扰。

　　虽然 OutOfMemoryError通常都是内存泄漏的信号，但是也有可能应用程序确实正在使用这么多的内存；对于后者，或者必须增加JVM可用的堆的数 量，或者对应用程序进行某种更改，使它使用较少的内存。但是，在许多情况下，OutOfMemoryError都是内存泄漏的信号。一种查明方法是不间断 地监控GC的活动，确定内存使用量是否随着时间增加。如果确实如此，就可能发生了内存泄漏。

详细输出

　　有许多监控垃圾收集器活动的方法。而其中使用最广泛的可能是使用-Xverbose:gc选项启动JVM，并观察输出。

[memory ] 10.109-10.235: GC 65536K->16788K (65536K), 126.000 ms
　箭头后面的值（本例中是16788K）是垃圾收集所使用的堆的容量。

控制台

　　查看连续不断的GC的详细统计信息的输出将是非常乏味的。幸好有这方面的工具。JRockit Management Console可以显示堆使用量的图示。借助于该图，可以很容易地看出堆使用量是否随时间增加。

Figure 1. The JRockit Management Console

甚至可以配置该管理控制台，以便如果发生堆使用量过大的情况（或基于其他的事件），控制台能够向您发送电子邮件。这明显使内存泄漏的查看变得更容易了。

内存泄漏检测工具

　　还有其他的专门进行内存泄漏检测的工具。JRockit Memory Leak Detector可以用来查看内存泄漏，并可以更深入地查出泄漏的根源。这个强大的工具是紧密集成到JRockit JVM中的，其开销非常小，对虚拟机的堆的访问也很容易。

专业工具的优点

　 　一旦知道确实发生了内存泄漏，就需要更专业的工具来查明为什么会发生泄漏。JVM自己是不会告诉您的。这些专业工具从JVM获得内存系统信息的方法基本 上有两种：JVMTI和字节码技术(byte code instrumentation)。Java虚拟机工具接口(Java Virtual Machine Tools Interface，JVMTI)及其前身Java虚拟机监视程序接口(Java Virtual Machine Profiling Interface，JVMPI)是外部工具与JVM通信并从JVM收集信息的标准化接口。字节码技术是指使用探测器处理字节码以获得工具所需的信息的技 术。

　　对于内存泄漏检测来说，这两种技术有两个缺点，这使它 们不太适合用于生产环境。首先，它们在内存占用和性能降低方面的开销不可忽略。有关堆使用量的信息必须以某种方式从JVM导出，并收集到工具中进行处理。 这意味着要为工具分配内存。信息的导出也影响了JVM的性能。例如，当收集信息时，垃圾收集器将运行得比较慢。另外一个缺点是需要始终将工具连在JVM 上。这是不可能的：将工具连在一个已经启动的JVM上，进行分析，断开工具，并保持JVM运行。

　 　因为JRockit Memory Leak Detector是集成到JVM中的，就没有这两个缺点了。首先，许多处理和分析工作是在JVM内部进行的，所以没有必要转换或重新创建任何数据。处理还 可以背负(piggyback)在垃圾收集器本身上而进行，这意味着提高了速度。其次，只要JVM是使用-Xmanagement选项（允许通过远程 JMX接口监控和管理JVM）启动的，Memory Leak Detector就可以与运行中的JVM进行连接或断开。当该工具断开时，没有任何东西遗留在JVM中，JVM又将以全速运行代码，正如工具连接之前一 样。

趋势分析

　 　让我们深入地研究一下该工具以及它是如何用来跟踪内存泄漏的。在知道发生内存泄漏之后，第一步是要弄清楚泄漏了什么数据--哪个类的对象引起了泄漏？ JRockit Memory Leak Detector是通过在每次垃圾收集时计算每个类的现有对象的数目来实现这一步的。如果特定类的对象数目随时间而增长（“增长率”），就可能发生了内存 泄漏。

图2. Memory Leak Detector的趋势分析视图

　 　因为泄漏可能像细流一样非常小，所以趋势分析必须运行很长一段时间。在短时间内，可能会发生一些类的局部增长，而之后它们又会跌落。但是趋势分析的开销 很小（最大开销也不过是在每次垃圾收集时将数据包由JRockit发送到Memory Leak Detector）。开销不应该成为任何系统的问题——即使是一个全速运行的生产中的系统。

　　起初数目会跳跃不停，但是一段时间之后它们就会稳定下来，并显示出哪些类的数目在增长。

找出根本原因

　 　有时候知道是哪些类的对象在泄漏就足以说明问题了。这些类可能只用于代码中的非常有限的部分，对代码进行一次快速检查就可以显示出问题所在。遗憾地是， 很有可能只有这类信息还并不够。例如，常见到泄漏出在类java.lang.String的对象上，但是因为字符串在整个程序中都使用，所以这并没有多大 帮助。

　　我们想知道的是，另外还有哪些对象与泄漏对象关联？ 在本例中是String。为什么泄漏的对象还存在？哪些对象保留了对这些对象的引用？但是能列出的所有保留对String的引用的对象将会非常多，以至于 没有什么实际用处。为了限制数据的数量，可以将数据按类分组，以便可以看出其他哪些对象的类与泄漏对象(String)关联。例如，String在 Hashtable中是很常见的，因此我们可能会看到与String关联的Hashtable数据项对象。由Hashtable数据项倒推，我们最终可以 找到与这些数据项有关的Hashtable对象以及String（如图3所示）。

图3. 在工具中看到的类型图的示例视图

倒推

　 　因为我们仍然是以类的对象而不是单独的对象来看待对象，所以我们不知道是哪个Hashtable在泄漏。如果我们可以弄清楚系统中所有的 Hashtable都有多大，我们就可以假定最大的Hashtable就是正在泄漏的那一个（因为随着时间的流逝它会累积泄漏而增长得相当大）。因此，一 份有关所有Hashtable对象以及它们引用了多少数据的列表，将会帮助我们指出造成泄漏的确切Hashtabl。

图4. 界面：Hashtable对象以及它们所引用数据的数量的列表

　 　对对象引用数据数目的计算开销非常大（需要以该对象作为根遍历引用图），如果必须对许多对象都这么做，将会花很多时间。如果了解一点Hashtable 的内部实现原理就可以找到一条捷径。Hashtable的内部有一个Hashtable数据项的数组。该数组随着Hashtable中对象数目的增长而增 长。因此，为找出最大的Hashtable，我们只需找出引用Hashtable数据项的最大数组。这样要快很多。

图5. 界面：最大的Hashtable数据项数组及其大小的清单

更进一步

　　当找到发生泄漏的Hashtable实例时，我们可以看到其他哪些实例在引用该Hashtable，并倒推回去看看是哪个Hashtable在泄漏。

图 6. 这就是工具中的实例图

　　例如，该Hashtable可能是由MyServer类型的对象在名为activeSessions的字段中引用的。这种信息通常就足以查找源代码以定位问题所在了。

图7. 检查对象以及它对其他对象的引用

找出分配位置

　 　当跟踪内存泄漏问题时，查看对象分配到哪里是很有用的。只知道它们如何与其他对象相关联（即哪些对象引用了它们）是不够的，关于它们在何处创建的信息也 很有用。当然了，您并不想创建应用程序的辅助构件，以打印每次分配的堆栈跟踪(stack trace)。您也不想仅仅为了跟踪内存泄漏而在运行应用程序时将一个分析程序连接到生产环境中。

　 　借助于JRockit Memory Leak Detector，应用程序中的代码可以在分配时进行动态添加，以创建堆栈跟踪。这些堆栈跟踪可以在工具中进行累积和分析。只要不启用就不会因该功能而产 生成本，这意味着随时可以进行分配跟踪。当请求分配跟踪时，JRockit 编译器动态插入代码以监控分配，但是只针对所请求的特定类。更好的是，在进行数据分析时，添加的代码全部被移除，代码中没有留下任何会引起应用程序性能降 低的更改。

图8. 示例程序执行期间String的分配的堆栈跟踪

结束语

　　内存泄漏是难以发现的。本文重点介绍了几种避免内存泄漏的最佳实践，包括要始终记住在数据结构中所放置的内容，以及密切监控内存使用量以发现突然的增长。

Hibernate配备了一种非常强大的查询语言，这种语言看上去很像SQL。但是不要被语法结构 上的相似所迷惑，HQL是非常有意识的被设计为完全面向对象的查询，它可以理解如继承、多态 和关联之类的概念。

Hibernate配备了一种非常强大的查询语言，这种语言看上去很像SQL。但是不要被语法结构 上的相似所迷惑，HQL是非常有意识的被设计为完全面向对象的查询，它可以理解如继承、多态 和关联之类的概念。

from eg.Cat

from Cat

from Cat as cat

from Cat cat

from Formula, Parameter

from Formula as form, Parameter as param

from Cat as cat 
    inner join cat.mate as mate
    left outer join cat.kittens as kitten

from Cat as cat left join cat.mate.kittens as kittens

from Formula form full join form.parameter param

from Cat as cat 
    join cat.mate as mate
    left join cat.kittens as kitten

from Cat as cat 
    inner join fetch cat.mate
    left join fetch cat.kittens

from Document fetch all properties order by name

from Document doc fetch all properties where lower(doc.name) like '%cats%'

select mate 
from Cat as cat 
    inner join cat.mate as mate

select cat.mate from Cat cat

select cat.name from DomesticCat cat
where cat.name like 'fri%'

select cust.name.firstName from Customer as cust

select mother, offspr, mate.name 
from DomesticCat as mother
    inner join mother.mate as mate
    left outer join mother.kittens as offspr

select new list(mother, offspr, mate.name)
from DomesticCat as mother
    inner join mother.mate as mate
    left outer join mother.kittens as offspr

select new Family(mother, mate, offspr)
from DomesticCat as mother
    join mother.mate as mate
    left join mother.kittens as offspr

select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n
from Cat cat

select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )
from Cat cat

select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)
from Cat cat

select cat.weight + sum(kitten.weight) 
from Cat cat 
    join cat.kittens kitten
group by cat.id, cat.weight

select firstName||' '||initial||' '||upper(lastName) from Person

select distinct cat.name from Cat cat

select count(distinct cat.name), count(cat) from Cat cat

from Cat as cat

from java.lang.Object o

from Named n, Named m where n.name = m.name

from Cat where name='Fritz'

from Cat as cat where cat.name='Fritz'

select foo 
from Foo foo, Bar bar
where foo.startDate = bar.date

from Cat cat where cat.mate.name is not null

from Foo foo  
where foo.bar.baz.customer.address.city is not null

from Cat cat, Cat rival where cat.mate = rival.mate

select cat, mate 
from Cat cat, Cat mate
where cat.mate = mate

from Cat as cat where cat.id = 123

from Cat as cat where cat.mate.id = 69

from bank.Person person
where person.id.country = 'AU' 
    and person.id.medicareNumber = 123456

from bank.Account account
where account.owner.id.country = 'AU' 
    and account.owner.id.medicareNumber = 123456

from Cat cat where cat.class = DomesticCat

store.owner.address.city    // 正确
store.owner.address         // 错误!

from AuditLog log, Payment payment 
where log.item.class = 'Payment' and log.item.id = payment.id

from DomesticCat cat where cat.name between 'A' and 'B'

from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )

from DomesticCat cat where cat.name not between 'A' and 'B'

from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )

<property name="hibernate.query.substitutions">true 1, false 0</property>

from Cat cat where cat.alive = true

from Cat cat where cat.kittens.size > 0

from Cat cat where size(cat.kittens) > 0

from Calendar cal where maxelement(cal.holidays) > current date

from Order order where maxindex(order.items) > 100

from Order order where minelement(order.items) > 10000

select mother from Cat as mother, Cat as kit
where kit in elements(foo.kittens)

select p from NameList list, Person p
where p.name = some elements(list.names)

from Cat cat where exists elements(cat.kittens)

from Player p where 3 > all elements(p.scores)

from Show show where 'fizard' in indices(show.acts)

from Order order where order.items[0].id = 1234

select person from Person person, Calendar calendar
where calendar.holidays['national day'] = person.birthDay
    and person.nationality.calendar = calendar

select item from Item item, Order order
where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11

select item from Item item, Order order
where order.items[ maxindex(order.items) ] = item and order.id = 11

select item from Item item, Order order
where order.items[ size(order.items) - 1 ] = item

select item, index(item) from Order order 
    join order.items item
where index(item) < 5

from DomesticCat cat where upper(cat.name) like 'FRI%'

select cust
from Product prod,
    Store store
    inner join store.customers cust
where prod.name = 'widget'
    and store.location.name in ( 'Melbourne', 'Sydney' )
    and prod = all elements(cust.currentOrder.lineItems)

SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order
FROM customers cust,
    stores store,
    locations loc,
    store_customers sc,
    product prod
WHERE prod.name = 'widget'
    AND store.loc_id = loc.id
    AND loc.name IN ( 'Melbourne', 'Sydney' )
    AND sc.store_id = store.id
    AND sc.cust_id = cust.id
    AND prod.id = ALL(
        SELECT item.prod_id
        FROM line_items item, orders o
        WHERE item.order_id = o.id
            AND cust.current_order = o.id
    )

from DomesticCat cat
order by cat.name asc, cat.weight desc, cat.birthdate

select cat.color, sum(cat.weight), count(cat) 
from Cat cat
group by cat.color

select foo.id, avg(name), max(name) 
from Foo foo join foo.names name
group by foo.id

select cat.color, sum(cat.weight), count(cat) 
from Cat cat
group by cat.color 
having cat.color in (eg.Color.TABBY, eg.Color.BLACK)

select cat
from Cat cat
    join cat.kittens kitten
group by cat
having avg(kitten.weight) > 100
order by count(kitten) asc, sum(kitten.weight) desc

from Cat as fatcat 
where fatcat.weight > ( 
    select avg(cat.weight) from DomesticCat cat 
)

from DomesticCat as cat 
where cat.name = some ( 
    select name.nickName from Name as name 
)

from Cat as cat 
where not exists ( 
    from Cat as mate where mate.mate = cat 
)

from DomesticCat as cat 
where cat.name not in ( 
    select name.nickName from Name as name 
)

from Cat as cat 
where not ( cat.name, cat.color ) in ( 
    select cat.name, cat.color from DomesticCat cat 
)

from Person where name = ('Gavin', 'A', 'King')

from Person where name.first = 'Gavin' and name.initial = 'A' and name.last = 'King')

select order.id, sum(price.amount), count(item)
from Order as order
    join order.lineItems as item
    join item.product as product,
    Catalog as catalog
    join catalog.prices as price
where order.paid = false
    and order.customer = :customer
    and price.product = product
    and catalog.effectiveDate < sysdate
    and catalog.effectiveDate >= all (
        select cat.effectiveDate 
        from Catalog as cat
        where cat.effectiveDate < sysdate
    )
group by order
having sum(price.amount) > :minAmount
order by sum(price.amount) desc

select order.id, sum(price.amount), count(item)
from Order as order
    join order.lineItems as item
    join item.product as product,
    Catalog as catalog
    join catalog.prices as price
where order.paid = false
    and order.customer = :customer
    and price.product = product
    and catalog = :currentCatalog
group by order
having sum(price.amount) > :minAmount
order by sum(price.amount) desc

select count(payment), status.name 
from Payment as payment 
    join payment.currentStatus as status
    join payment.statusChanges as statusChange
where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
    or (
        statusChange.timeStamp = ( 
            select max(change.timeStamp) 
            from PaymentStatusChange change 
            where change.payment = payment
        )
        and statusChange.user <> :currentUser
    )
group by status.name, status.sortOrder
order by status.sortOrder

select count(payment), status.name 
from Payment as payment
    join payment.currentStatus as status
where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
    or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser
group by status.name, status.sortOrder
order by status.sortOrder

select account, payment
from Account as account
    left outer join account.payments as payment
where :currentUser in elements(account.holder.users)
    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
order by account.type.sortOrder, account.accountNumber, payment.dueDate

select account, payment
from Account as account
    join account.holder.users as user
    left outer join account.payments as payment
where :currentUser = user
    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
order by account.type.sortOrder, account.accountNumber, payment.dueDate

( (Integer) session.iterate("select count(*) from ....").next() ).intValue()

select usr.id, usr.name
from User as usr 
    left join usr.messages as msg
group by usr.id, usr.name
order by count(msg)

from User usr where size(usr.messages) >= 1

select usr.id, usr.name
from User usr.name
    join usr.messages msg
group by usr.id, usr.name
having count(msg) >= 1

select usr.id, usr.name
from User as usr
    left join usr.messages as msg
group by usr.id, usr.name
having count(msg) = 0

Query q = s.createQuery("from foo Foo as foo where foo.name=:name and foo.size=:size");
q.setProperties(fooBean); // fooBean包含方法getName()与getSize()
List foos = q.list();

Query q = s.createFilter( collection, "" ); // 一个简单的过滤器
q.setMaxResults(PAGE_SIZE);
q.setFirstResult(PAGE_SIZE * pageNumber);
List page = q.list();

Collection orderedCollection = s.filter( collection, "order by this.amount" );
Collection counts = s.filter( collection, "select this.type, count(this) group by this.type" );

( (Integer) session.iterate("select count(*) from ....").next() ).intValue();

一 准备

	192.168.0.1	www.sentom1.net
	192.168.0.1	www.sentom2.net

二 Tomcat安装

	tomcat
	   |--bin
	   |--common
	   |--conf
	   |--logs
	   |--server
	   |--shared
	   ......
	   |--webpapps1
	   |--webpapps2
	   |--work

<HTML>
<HEAD>
<TITLE>测试</TITLE>
</HEAD>

<BODY>
<P align="center">你现在访问的是 <FONT COLOR="#FF0000">www.sentom1.net</FONT></P>
</BODY>
</HTML>

三 配置虚拟主机

    <Host name="www.sentom1.net" debug="0" appBase="webapps1"
             unpackWARs="true" autoDeploy="true">

        <Valve className="org.apache.catalina.valves.AccessLogValve"
                 directory="logs"  prefix="sentom1_access_log." suffix=".txt"
                 pattern="common" resolveHosts="false"/>

        <Logger className="org.apache.catalina.logger.FileLogger"
                 directory="logs"  prefix="sentom1_log." suffix=".txt"
                 timestamp="true"/>

      </Host>

    <Host name="www.sentom2.net" debug="0" appBase="webapps2"
             unpackWARs="true" autoDeploy="true">

        <Valve className="org.apache.catalina.valves.AccessLogValve"
                 directory="logs"  prefix="sentom2_access_log." suffix=".txt"
                 pattern="common" resolveHosts="false"/>

        <Logger className="org.apache.catalina.logger.FileLogger"
                 directory="logs"  prefix="sentom2_log." suffix=".txt"
                 timestamp="true"/>

      </Host>

你现在访问的是 www.sentom1.net

你现在访问的是 www.sentom2.net

四 参考

java.util包中包含了一系列重要的集合类。本文将从分析源码入手，深入研究一个集合类的内部结构，以及遍历集合的迭代模式的源码实现内幕。

下面我们先简单讨论一个根接口Collection，然后分析一个抽象类AbstractList和它的对应Iterator接口，并仔细研究迭代子模式的实现原理。

本文讨论的源代码版本是JDK 1.4.2，因为JDK 1.5在java.util中使用了很多泛型代码，为了简化问题，所以我们还是讨论1.4版本的代码。

集合类的根接口Collection

Collection接口是所有集合类的根类型。它的一个主要的接口方法是：

    boolean add(Object c)

add()方法将添加一个新元素。注意这个方法会返回一个boolean，但是返回值不是表示添加成功与否。仔细阅读doc可以看到， Collection规定：如果一个集合拒绝添加这个元素，无论任何原因，都必须抛出异常。这个返回值表示的意义是add()方法执行后，集合的内容是否 改变了（就是元素有无数量，位置等变化），这是由具体类实现的。即：如果方法出错，总会抛出异常；返回值仅仅表示该方法执行后这个Collection的 内容有无变化。

类似的还有：

    boolean addAll(Collection c);
    boolean remove(Object o);
    boolean removeAll(Collection c);
    boolean remainAll(Collection c);

Object[] toArray()方法很简单，把集合转换成数组返回。Object[] toArray(Object[] a)方法就有点复杂了，首先，返回的Object[]仍然是把集合的所有元素变成的数组，但是类型和参数a的类型是相同的，比如执行：

    String[] o = (String[])c.toArray(new String[0]);

得到的o实际类型是String[]。

其次，如果参数a的大小装不下集合的所有元素，返回的将是一个新的数组。如果参数a的大小能装下集合的所有元素，则返回的还是a，但a的内容用集合的元素来填充。尤其要注意的是，如果a的大小比集合元素的个数还多，a后面的部分全部被置为null。

最后一个最重要的方法是iterator()，返回一个Iterator（迭代子），用于遍历集合的所有元素。

用Iterator模式实现遍历集合

Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。

例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：

    for(int i=0; i<array.size(); i++) { ... get(i) ... }

而访问一个链表（LinkedList）又必须使用while循环：

    while((e=e.next())!=null) { ... e.data() ... }

以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。

更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。

为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：

    for(Iterator it = c.iterater(); it.hasNext(); ) { ... }

奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。

客户端从不直接和集合类打交道，它总是控制Iterator，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。

首先看看java.util.Iterator接口的定义：

    public interface Iterator {
        boolean hasNext();
        Object next();
        void remove();
    }

依赖前两个方法就能完成遍历，典型的代码如下：

    for(Iterator it = c.iterator(); it.hasNext(); ) {
        Object o = it.next();
        // 对o的操作...
    }

在JDK1.5中，还对上面的代码在语法上作了简化：

    // Type是具体的类型，如String。
    for(Type t : c) {
        // 对t的操作...
    }

每一种集合类返回的Iterator具体类型可能不同，Array可能返回ArrayIterator，Set可能返回SetIterator， Tree可能返回TreeIterator，但是它们都实现了Iterator接口，因此，客户端不关心到底是哪种Iterator，它只需要获得这个 Iterator接口即可，这就是面向对象的威力。

Iterator源码剖析

让我们来看看AbstracyList如何创建Iterator。首先AbstractList定义了一个内部类（inner class）：

    private class Itr implements Iterator {
        ...
    }

而iterator()方法的定义是：

    public Iterator iterator() {
        return new Itr();
    }

因此客户端不知道它通过Iterator it = a.iterator();所获得的Iterator的真正类型。

现在我们关心的是这个申明为private的Itr类是如何实现遍历AbstractList的：

    private class Itr implements Iterator {
        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;
    }

Itr类依靠3个int变量（还有一个隐含的AbstractList的引用）来实现遍历，cursor是下一次next()调用时元素的位置，第一次调用next()将返回索引为0的元素。lastRet记录上一次游标所在位置，因此它总是比cursor少1。

变量cursor和集合的元素个数决定hasNext()：

    public boolean hasNext() {
        return cursor != size();
    }

方法next()返回的是索引为cursor的元素，然后修改cursor和lastRet的值：

    public Object next() {
        checkForComodification();
        try {
            Object next = get(cursor);
            lastRet = cursor++;
            return next;
        } catch(IndexOutOfBoundsException e) {
            checkForComodification();
            throw new NoSuchElementException();
        }
    }

expectedModCount表示期待的modCount值，用来判断在遍历过程中集合是否被修改过。AbstractList包含一个 modCount变量，它的初始值是0，当集合每被修改一次时（调用add，remove等方法），modCount加1。因此，modCount如果不 变，表示集合内容未被修改。

Itr初始化时用expectedModCount记录集合的modCount变量，此后在必要的地方它会检测modCount的值：

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }

如果modCount与一开始记录在expectedModeCount中的值不等，说明集合内容被修改过，此时会抛出ConcurrentModificationException。

这个ConcurrentModificationException是RuntimeException，不要在客户端捕获它。如果发生此异常，说明程序代码的编写有问题，应该仔细检查代码而不是在catch中忽略它。

但是调用Iterator自身的remove()方法删除当前元素是完全没有问题的，因为在这个方法中会自动同步expectedModCount和modCount的值：

    public void remove() {
        ...
        AbstractList.this.remove(lastRet);
        ...
        // 在调用了集合的remove()方法之后重新设置了expectedModCount：
        expectedModCount = modCount;
        ...
    }

要确保遍历过程顺利完成，必须保证遍历过程中不更改集合的内容（Iterator的remove()方法除外），因此，确保遍历可靠的原则是只在一个线程中使用这个集合，或者在多线程中对遍历代码进行同步。

最后给个完整的示例：

    Collection c = new ArrayList();
    c.add("abc");
    c.add("xyz");
    for(Iterator it = c.iterator(); it.hasNext(); ) {
        String s = (String)it.next();
        System.out.println(s);
    }

如果你把第一行代码的ArrayList换成LinkedList或Vector，剩下的代码不用改动一行就能编译，而且功能不变，这就是针对抽象编程的原则：对具体类的依赖性最小。

/**********************************************************************

这个算是比较满意的答案了。

摘要:

#
# @(#)jvm.cfg        1.7 03/01/23
# 
# Copyright 2003 Sun Microsystems, Inc. All rights reserved.
# SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
# 
# 
#
#
# List of JVMs that can be used as an option to java, javac, etc.
# Order is important -- first in this list is the default JVM.
# NOTE that this both this file and its format are UNSUPPORTED and
# WILL GO AWAY in a future release.
#
# You may also select a JVM in an arbitrary location with the
# "-XXaltjvm=<jvm_dir>" option, but that too is unsupported
# and may not be available in a future release.
#
-client KNOWN
-server KNOWN
-hotspot ALIASED_TO -client
-classic WARN
-native ERROR
-green ERROR

typedef struct {
    CreateJavaVM_t CreateJavaVM;
    GetDefaultJavaVMInitArgs_t GetDefaultJavaVMInitArgs;
} InvocationFunctions;

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft]

[HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment]
"CurrentVersion"="1.4"

[HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment\1.4]
"JavaHome"="D:\\java\\j2sdk1.4.2_04\\jre"

E:\temp>java
Usage: java [-options] class [args...]
           (to execute a class)
   or  java [-options] -jar jarfile [args...]
           (to execute a jar file)

where options include:
    -client       to select the "client" VM
    -server       to select the "server" VM
    -hotspot      is a synonym for the "client" VM  [deprecated]
                  The default VM is client.

    -cp <class search path of directories and zip/jar files>
    -classpath <class search path of directories and zip/jar files>
                  A ; separated list of directories, JAR archives,
                  and ZIP archives to search for class files.
    -D<name>=<value>
                  set a system property
    -verbose[:class|gc|jni]
                  enable verbose output
    -version      print product version and exit
    -showversion  print product version and continue
    -? -help      print this help message
    -X            print help on non-standard options
    -ea[:<packagename>...|:<classname>]
    -enableassertions[:<packagename>...|:<classname>]
                  enable assertions
    -da[:<packagename>...|:<classname>]
    -disableassertions[:<packagename>...|:<classname>]
                  disable assertions
    -esa | -enablesystemassertions
                  enable system assertions
    -dsa | -disablesystemassertions
                  disable system assertions

public class TestProcess {

 /**
  * @param args
  */
 public static void main(String[] args) {
  System.out.println("runtime~~~~");
  ProcessExec p = new ProcessExec();
  int i = 2;
  try{
   i = p.process11();
  }catch(IOException e){
   
  }
  System.out.println(i);
 }
 
}

class ProcessExec{
 public int process11() throws IOException{
//  Process process = Runtime.getRuntime().exec("C:/Program Files/Outlook Express/msimn.exe");
  Process process = Runtime.getRuntime().exec("cmd.exe /c");
//  Process process = Runtime.getRuntime().exec("C:/WINDOWS/system32/cmd.exe");
  int i=4;
  try{
   i = process.waitFor();
  }catch(InterruptedException e){
   i=3;
  }
  return i;
 }
}