久草精品视频,久久一区二区三区喷水,色婷婷综合久久久

JavaEye三周�q�_��大家聊聊最喜欢的帖子一、你擦了吗？��定擦了�Q�真的确定擦了？

何以解忧�Q�唯有学习！让每一个�h都能Open Source — Thu, 31 Aug 2006 00:48:00 GMT

应用try-finally�Q�我们可以在异常满天飞的�E�序里保证我们的关键资源被按时正��清理。一个最常见的应用就是jdbc的Connection, Statement, ResultSet�{��?

但是�Q�我最�q�惊奇地发现�Q�不知道怎么正确清理资源的�h大有人在�Q�即使是一些java老手�?

看一个例子先�Q?

java代码:

												

												void f(){
  Connection conn = ...; 
  Statement stmt = conn.createStatement(); 
  ResultSet rset = ...; 
  ... 
}

典型的jdbc�E�序。但是也是典型的光着屁股�Q�其臭如兰地走出厕所的典范。哎�Q�你擦屁股了吗？
有的哥们振振有辞�Q�我不用��，我的jdbc driver/我的应用服务�?garbage collector会处理的�?
�q�是典型的糊涂蛋逻辑。没有close()�Q�jdbc driver, 应用服务器怎么知道你是拉完了，�q�是光着屁股出去接个电话先？难不成这driver都智能地会算命了�Q?
garbage collector倒确实管得了。不�q�，garbage collector不一定运行啊。你要是�?0G得内存，要是你的�E�序��q��?0M�Q�garbage collector说不定就一直睡大觉。而且�Q�就��它��，也许�{�你光着屁股上班被警察抓��h��之后才匆匆赶刎ͼ�你等的�v吗？

好，有�h��_��那我擦，我擦�Q�我擦擦擦。行了吧�Q?

java代码:

												

												void f(){
  Connection conn = ...; 
  Statement stmt = conn.createStatement(); 
  ResultSet rset = ...; 
  rset.close(); 
  conn.close(); 
  ... 
}

呵呵。我的傻哥们�Q�你只擦了靠�q�后背的那三公分�Q�剩下的嘛，别�h看不见你��׃��得省土块儿了是么�Q?

按jdbc标准�Q�ResultSet, Statement, Connection都要close()�Q�也许有的driver会在Connection关闭的时候同时正��清理ResultSet, Statement�Q�但是，�q�没有一条规定让所有的driver都这么做�?
另外�Q�也�怽�的Connection是从一个池里面来的�Q�它只是回到池中去，如果你不关闭Statement, ResultSet�Q�下一个拿到这个Connection的�h也许��倒霉了！
做事要有始有�l�，既然开始擦了，��擦�q�净点儿�Q�行不？�Q�那个，谁谁谁，借我个防毒面具先�Q�）

ok�Q�有个讲卫生的小��d��q�样擦：

java代码:

												

												void f(){
  Connection conn = ...; 
  Statement stmt = conn.createStatement(); 
  ResultSet rset = ...; 
  rset.close(); 
  stmt.close(); 
  conn.close(); 
  ... 
}

然后�z�洋得意地说�Q�我是好孩子�Q�我天天擦屁屁�?

是啊�Q�多听话的孩子呀。可惜，某天�Q�这孩子正坐在马桶上��着呢，妈妈喊了嗓子�Q�二��d��Q�吃饭啦�?
哦！吃饭。二��d��裤子都没提就�H�出来了�Q�熏得妈妈一个跟头�?

什么问题，��d��做事一根筋�Q�不能打扎ͼ�一旦有异常情况出现�Q�屁股就忘了擦了�?

所以，我这里郑重提醒大�Ӟ��L��"try-finally"�Q�它独有�Ҏ��Q�防止侧�?..�Q�糟了，串台了）

是啊�Q�java老手们都不是��d��Q�都知道用try-finally的，可是�Q�别��，你现在就保不齐擦没擦屁股呢！

常见擦法�Q?

java代码:

												

												void f(){
  Connection conn = null; 
  Statement stmt = null; 
  ResultSet rset = null; 
  try{
    conn = ...; 
    stmt = ...; 
    rset = ...; 
    ... 
  }
  finally{
      if(rset!=null)rset.close(); 
      if(stmt!=null)stmt.close(); 
      if(conn!=null)conn.close(); 

  }
}

嗯。怎么说呢。挺聪明的。都学会if(xxx!=null)�q�种传说中条件判断的上古�l�学了�?
可惜�Q�你屁股大，一张纸不够�Q�你用了�W�一张纸�Q�满意地看着它圆满地完成了金灿灿的�Q务，再用�W�二张，靠，只太薄，破了�Q�一手金灿灿圎ͼ�象带了个金戒指。你大怒，��P��l�尘而去。于是也忘了�W�三张纸�Q?
哥们儿，close()是可以出异常的，你rset关了�Q�stmt.close()出现了异常，但是conn��׃��了�Q?

�q�日有位室外高�h�Q�据说是��D��子高徒，鉴于怜我世�h�Q�不擦屁股的实多的高��情操，亲手赚写一本绝世擦功秘�c�，其文��，其意高，除了擦不�q�净之外�Q�真可以说是�U�霸擦林�?

java代码:

												

												

												void close(Connection conn){
  try{
    if(conn!=null) conn.close(); 
  }
  catch(Exception e){
    e.printStackTrace(); 
  }
}
void close(ResultSet rset){
  ... 
}
void close(Statement rset){
  ... 
}
void f(){
  Connection conn = null; 
  Statement stmt = null; 
  ResultSet rset = null; 
  try{
    conn = ...; 
    stmt = ...; 
    rset = ...; 
    ... 
  }
  finally{
     close(rset); 
     close(stmt); 
     close(conn); 

  }
}

哈，你们不能�U�擦破了��׃��接着擦啊�Q�甚臛_��而化之，不能擦股用具有了问题��半途而废呀�Q?

具信�Q�该高�h以此法擦遍天下凡十数载，未有擦而无功者�?

可惜�Q�高人却忽视了，除了�U怼�出故障，甚至大而化之，一切擦��P��如土块儿�Q�木条儿�Q�手指）都可能出现故障，�q�有别的地方也会出故障地�Q?
除了Exception�Q�还有Error啊，我的高�h�Q�如果close(rset)抛了一个Error�Q�你的close(stmt), close(conn)不都歇菜了？

后来�Q�高人在《绝世武功补遗》里面解释说�Q�Error代表不可恢复错误�Q�说明整个排泄大业都受阻了，所以根本不应该试图对这�U�情况做��M��处理�Q�你也处理不了（自然也隐含此时你也根本无法擦屁股了的论断�Q�。�Q何试囑֜��q�种情况下仍然固执擦屁股的做法都是倒行逆施�Q�螳臂当车，必然被历史的车轮所�늢��?

此书一处，天下辟易。其革命性之��p��Q�难以估量。具有关斚w��评论�Q�Sun�q�个公共厕所的try-finally�q�个工具的设定本�w�就是不合理的，应该被历史�R轮撵��的�Q�因为try-finally居然试图在出现Error的时候去做一些事情！是可忍，��C��可忍�Q?
可以预见�Q�try-finally��被sun��d��废弃�Q��ƈ且向�q�大公众做公开道歉以检讨多�q�来的欺骗造成的恶劣媄响�?
另外�Q�公厕的构造也受到质疑�Q�因��Z��旦有一个拉客在擦的时候某一步无可挽回地��p�|�Q�比如，太紧张，手一抖，�U�掉��C��坑里�Q�又��L��伸手捞不着�Q�，那么他就大摇大摆不再�l�箋擦，而如果碰巧此人刚吃了萝卜�Q�就会把整个厕所里的其它拉客都熏得无法��l�。（��x��一个app server吧。你一个程序歇菜，乐得��L��假不擦了�Q�别��Z��跟着倒霉�Q�）

嘿嘿�Q�那么，你擦了吗�Q�你肯定你擦了？擦干净了？

�q�好�Q�我们翻遍上古秘�c�，最�l�在北京山顶�z��h的失传宝典《呼��|��擦！》中发现了一个据�U�绝对干净的擦法，那就是－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?

一下一下擦�Q?

具体操作办法如下�Q?

java代码:

												

												

												void f(){
  finalConnection conn = ...; 
  try{
    finalStatement stmt = ...; 
    try{
      finalResultSet rset = ...; 
      try{
        ... 
      }
      finally{rset.close();}
    }
    finally{stmt.close();}
  }
  finally{conn.close();}
}

其诀�H�就是，每徏立一个需要清理的资源�Q�就用一个try-finally来保证它可以被清理掉�?

如此�Q��Q何时候，你都是屁股干�q�静静地��d��卫生间�?

哪。好多圣人门徒跟我说�Q�这样一下一下擦�Q�姿劉K��怸�雅观�Q�看看那嵌套的try块吧�Q�，有违古礼。我们反对！

靠，你说孔丑儿古�q�是山顶�z��h古？�Q?
屁股�q�泛着呛_��呢，�q�拽什么“雅”？

而且�Q�要是死要面子，也可以拉个帘子，擦的时候别让�h看见嘛。比如：

java代码:

												

												

												interface ResultListener{
  void call(ResultSet rset); 
}
class SqlReader{
void read(ResultListener l){
    finalConnection conn = ...; 
    try{
      finalStatement stmt = ...; 
      try{
        finalResultSet rset = ...; 
        try{
          l.call(rset); 
        }
        finally{rset.close();}
      }
      finally{stmt.close();}
    }
    finally{conn.close();}
  }
}

�q�一下一下擦的动作都藏在SqlReader�q�个帘子里，你直接在ResultListener里面拉不��p��了？

那位高�h说了�Q�这太复杂，��׃ؓ了擦个屁股不倹{�?

�q�个嘛，��g��值的另说�Q�你那个��单，��是��单单地擦不干净屁股。要不您�q�脆别擦得了�Q�更��单呢�q�。反正您出门儿就愣说擦的是Chanel香水儿就是了。有啥比瞪眼儿说白话儿简单？

对了�Q?我还忘了一个条�ƾ：
��是擦屁股的时候按��序擦。谁�?/span>�q�厕所的，要让人家�?/span>出去�?

“什么狗屁规则？“那位问了�?

�q�个�q�个--�Q�啊�Q�你猜猜~~~�Q?

嗯，对了�Q�是�q�样的，上厕所都不着急，姗姗来迟�Q�上课更不着急，更喜�Ƣ迟��C��Q�对不对�Q�而谁上课天天�q�到早退�q�不担心毕业�Q�当然是太子党了�Q�是不？
人家都太子党了，你还不让人家先出去？�z�腻味了你？�Q�此处尾韌��拉长�Q�而且向上拐）

反正啊，具体��_��ResultSet最后创建，但是要先兟�?

Statement其次。Connection最后�?

当然了，也许在你的环境下�Q�次序错了也没出事情。但是，�׃��吃��Y饭的�Q�吃软�g�q�口饭的�Q�图啥？不就图个攑ֿ�吗？上厕所囑֕��Q�不��图个别让太子党抓去当兔子吗�Q?
也许某个driver�Ҏ��序不敏感�Q�但是不好说哪天你换个环境就忽然她奶奶的敏感了呢�Q?
比如吧，你有connection pool, conn.close()把connection�q�回到connection�?

你要是先conn.close()�Q�好嘛，connection先回到pool了，正好别的�U�程里面�{�着要connection�Q�立马这个connection又给分配出去了�?
�q�下齐了�Q�你statement, resultset�q�没兛_��Q�那边事故单位领导就找上门了。什么香�Ҏ�a的桌子，什么桐油炸丸子�Q�全�l�你送来了。这不添堵吗�Q?

好在�Q�在我们《呼��|��擦！》宝�怸�记蝲的“一下一下擦”神功，老少咸宜�Q�童叟无�ƺ，有道是：法擦大法好，不如法擦冰箱好！

跑题了。反正是�Q�只要你一个try-finally对应一个资源，你就不可能在�ơ序上出错。自然而然的就是后入先出的堆栈�l�构�?
反观别的擦法�Q�就没有�q�个效果�Q�次序如何，全靠你自己掌握。弄错了�Q�系�l�也不告诉你。等着吃桐油炸丸子吧�?

�q�也是我们推�q�一下一下擦的一个原因�?/span>

上一�ơ由ajoo�?005-6-09 周四, 下午12:45修改�Q��d��修改�?��?/span>

何以解忧�Q�唯有学习！让每一个�h都能Open Source 2006-08-31 08:48 发表评论

何以解忧�Q�唯有学习！让每一个�h都能Open Source — Sun, 30 Jul 2006 12:51:00 GMT

�Ҏ��一�Q�在servlet的init()�Ҏ��中缓存数�?/font>
当应用服务器初始化servlet实例之后�Q��ؓ客户端请求提供服务之前，它会调用�q�个servlet的init()�Ҏ��。在一个servlet的生命周期中�Q�init()�Ҏ��只会被调用一�ơ。通过在init()�Ҏ��中缓存一些静态的数据或完成一些只需要执行一�ơ的、耗时的操作，��可大大地提高系�l�性能�?br />　　例如�Q�通过在init()�Ҏ��中徏立一个JDBC�q�接池是一个最佳例子，假设我们是用jdbc2.0的DataSource接口来取得数据库�q�接�Q�在通常的情况下�Q�我们需要通过JNDI来取得具体的数据源。我们可以想象在一个具体的应用中，如果每次SQL��h��都要执行一�ơJNDI查询的话�Q�那�pȝ��性能��会急剧下降。解��x��法是如下代码�Q�它通过�~�存DataSource�Q��得下一�ơSQL调用时仍然可以��l�利用它�Q?br />public class ControllerServlet extends HttpServlet
{
　private javax.sql.DataSource testDS = null;
　public void init(ServletConfig config) throws ServletException
　{
　　super.init(config);
　　Context ctx = null;
　　try
　　{
　　　ctx = new InitialContext();
　　　testDS = (javax.sql.DataSource)ctx.lookup("jdbc/testDS");
　　}
　　catch(NamingException ne)
　　{
　　　ne.printStackTrace();
　　}
　　catch(Exception e)
　　{
　　　e.printStackTrace();
　　}
　}

　public javax.sql.DataSource getTestDS()
　{
　　return testDS;
　}
　...
　...
}

�Ҏ�� 2:��止servlet和JSP 自动重蝲(auto-reloading)
　　Servlet/JSP提供了一个实用的技术，卌��动重载技术，它�ؓ开发�h员提供了一个好的开发环境，当你改变servlet和JSP��面后而不必重启应用服务器。然而，�q�种技术在产品�q�行阶段对系�l�的资源是一个极大的损耗，因�ؓ它会�l�JSP引擎的类装蝲�?classloader)带来极大的负担。因此关闭自动重载功能对�pȝ��性能的提升是一个极大的帮助�?br />
�Ҏ�� 3: 不要滥用HttpSession
　　在很多应用中�Q�我们的�E�序需要保持客��L��的状态，以便��面之间可以�怺�联系。但不幸的是�׃��HTTP��h��天生无状态性，从而无法保存客��L��的状态。因此一般的应用服务器都提供了session来保存客��L��状态。在JSP应用服务器中�Q�是通过HttpSession对像来实现session的功能的�Q�但在方便的同时�Q�它也给�pȝ��带来了不��的负担。因为每当你获得或更新session�Ӟ��pȝ��者要对它�q�行�Ҏ��的序列化操作。你可以通过对HttpSession的以下几�U�处理方式来提升�pȝ��的性能�Q?br />
　　1�?如果没有必要�Q�就应该关闭JSP��面中对HttpSession的缺省设�|�：如果你没有明��指定的话，每个JSP��面都会�~�省地创��Z��个HttpSession。如果你的JSP中不需要��用session的话�Q�那可以通过如下的JSP��面指示�W�来��止它：
�Q?@ page session="false"%�Q?

　　2�?不要在HttpSession中存攑֤�的数据对像：如果你在HttpSession中存攑֤�的数据对像的话，每当对它�q�行��d��Ӟ��应用服务器都��对其进行序列化�Q�从而增加了�pȝ��的额外负担。你在HttpSession中存攄��数据对像��大�Q�那�pȝ��的性能��׃��降得��快�?br />
　　3、当你不需要HttpSession�Ӟ��快地释攑֮��Q�当你不再需要session�Ӟ��你可以通过调用HttpSession.invalidate()�Ҏ��来释攑֮��?br />
　　4、尽量将session的超时时间设得短一点：在JSP应用服务器中�Q�有一个缺省的session的超时时间。当客户在这个时间之后没有进行�Q何操作的话，�pȝ��会将相关的session自动从内存中释放。超时时间设得越大，�pȝ��的性能��׃��低�Q�因此最好的�Ҏ��是��量使得它的��g��持在一个较低的水��^�?br />
�Ҏ�� 4: ��页面输��行压�~?br />
　　压羃是解��x��据冗余的一个好的方法，特别是在�|�络带宽不够发达的今天。有的浏览器支持gzip(GNU zip)�q�行来对HTML文�g�q�行压羃�Q�这�U�方法可以戏剧性地减少HTML文�g的下载时间。因此，如果你将servlet或JSP��面生成的HTML��面�q�行压羃的话�Q�那用户��׃��觉得��面��览速度会非常快。但不幸的是�Q�不是所有的��览器都支持gzip压羃�Q�但你可以通过在你的程序中��查客��L��览器是否支持它。下面就是关于这�U�方法实现的一个代码片�D�：

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException
{
　OutputStream out = null
　String encoding = request.getHeader("Accept-Encoding");
　if (encoding != null && encoding.indexOf("gzip") != -1)
　{
　　request.setHeader("Content-Encoding" , "gzip");
　　out = new GZIPOutputStream(request.getOutputStream());
　}
　else if (encoding != null && encoding.indexOf("compress") != -1)
　{
　　request.setHeader("Content-Encoding" , "compress");
　　out = new ZIPOutputStream(request.getOutputStream());
　}
　else
　{
　　out = request.getOutputStream();
　}
　...
　...
}

�Ҏ�� 5: 使用�U�程�?/font>
　　应用服务器缺省地为每个不同的客户端请求创��Z��个线�E�进行处理，�q��ؓ它们分派service()�Ҏ��Q�当service()�Ҏ��调用完成后，与之相应的线�E�也随之撤消。由于创建和撤消�U�程会耗费一定的�pȝ��资源�Q�这�U�缺省模式降低了�pȝ��的性能。但所�q�的是我们可以通过创徏一个线�E�池来改变这�U�状��c��另外，我们�q�要��个线�E�池讄��一个最��线�E�数和一个最大线�E�数。在应用服务器启动时�Q�它会创建数量等于最��线�E�数的一个线�E�池�Q�当客户有请求时�Q�相应地从池从取��Z��个线�E�来�q�行处理�Q�当处理完成后，再将�U�程重新攑օ�到池中。如果池中的�U�程不够地话�Q�系�l�会自动地增加池中线�E�的数量�Q�但总量不能��过最大线�E�数。通过使用�U�程池，当客��L��h��急剧增加�Ӟ��pȝ��的负载就会呈现的�q�x��的上升曲�U�，从而提高的�pȝ��的可伸羃性�?br />
�Ҏ�� 6: 选择正确的页面包含机�?/font>
　　在JSP中有两种�Ҏ��可以用来包含另一个页面：1、��用include指示�W?�Q?@ includee file=”test.jsp�?%�Q?�?、��用jsp指示�W?�Q�jsp:includee page=”test.jsp�?flush=”true�?�Q?。在实际中我发现�Q�如果��用第一�U�方法的话，可以使得�pȝ��性能更高�?br />
�Ҏ�� 7:正确地确定javabean的生命周�?/font>
　　JSP的一个强大的地方��是对javabean的支持。通过在JSP��面中��用＜jsp:useBean�Q�标�{�，可以��javabean直接插入��C��个JSP��面中。它的��用方法如下：
�Q�jsp:useBean id="name" scope="page|request|session|application" class=
"package.className" type="typeName"�Q?br />�Q?jsp:useBean�Q?

　　其中scope属性指��Z��q�个bean的生命周期。缺省的生命周期为page。如果你没有正确地选择bean的生命周期的话，它将影响�pȝ��的性能�?br />　　举例来说�Q�如果你只想在一�ơ请求中使用某个bean�Q�但你却��这个bean的生命周期设�|�成了session�Q�那当这�ơ请求结束后�Q�这个bean��仍然保留在内存中，除非session��时或用户关闭浏览器。这样会耗费一定的内存�Q��ƈ无谓的增加了JVM垃圾攉��器的工作量。因此�ؓbean讄��正确的生命周期，�q�在bean的��命结束后��快地清理它们，会��用系�l�性能有一个提高�?br />
其它一些有用的�Ҏ��
　　1、在字符串连接操作中��量不��用“＋”操作符�Q�在java�~�程中，我们常常使用“＋”操作符来将几个字符串连接�v来，但你或许从来没有惛_��q�它居然会对�pȝ��性能造成影响吧？�׃��字符串是帔R��Q�因此JVM会��生一些��时的对像。你使用的“＋”越多，生成的��时对像就��多�Q�这样也会给�pȝ��性能带来一些媄响。解决的�Ҏ��是用StringBuffer对像来代曎쀜＋”操作符�?br />
　　2�?避免使用System.out.println()�Ҏ��Q�由于System.out.println()是一�U�同步调用，卛_��调用它时�Q�磁盘I/O操作必须�{�待它的完成�Q�因此我们要��量避免对它的调用。但我们在调试程序时它又是一个必不可��的方便工具�Q��ؓ了解册��个矛盾，我徏议你最好��用Log4j工具(http://Jakarta.apache.org )�Q�它既可以方便调试，而不会��生System.out.println()�q�样的方法�?br />
　　3�?ServletOutputStream �?PrintWriter的权�?使用PrintWriter可能会带来一些小的开销�Q�因为它��所有的原始输出都�{换�ؓ字符��来输出�Q�因此如果��用它来作为页面输出的话，�pȝ��要负担一个�{换过�E�。而��用ServletOutputStream作�ؓ��面输出的话��׃��存在一个问题，但它是以二进制进行输出的。因此在实际应用中要权衡两者的利弊�?br />
　　�ȝ��
　　本文的目的是通过对servlet和JSP的一些调优技术来极大地提高你的应用程序的性能�Q��ƈ因此提升整个J2EE应用的性能。通过�q�些调优技术，你可以发现其实�ƈ不是某种技术��^収ͼ�比如J2EE�?NET之争�Q�决定了你的应用�E�序的性能�Q�重要是你要对这�U��^台有一个较为深入的了解�Q�这样你才能从根本上对自��q��应用�E�序做一个优化！

何以解忧�Q�唯有学习！让每一个�h都能Open Source 2006-07-30 20:51 发表评论

用JAVA实现UBB代码

何以解忧�Q�唯有学习！让每一个�h都能Open Source — Tue, 11 Jul 2006 03:11:00 GMT

�怿�大家一定可以想到UBB代码的解析，其实��是��“[b][/b]”这��L��格式转换成““”就可以了，但是怎么转换呢？�{�案是用正则表达式。利用上一期讲到的正则表达式类(sony.utils.Regex)中的eregi_replace替换�Ҏ��Q�可以很��L��地做到。下面是一�D늤�例�?
　　String s="[b]�q�是�_�体[/b]";
　　String result;
　　result = Regex.eregi_replace("[b](.+?)[/b]","�?1�?, s);
　　System.out.println(result);
　　//打印�l�果是：
　　//“这是粗体“�?
�q�么��单吗�Q�是的，我们只需要将其它的UBB Tag作类似的替换��实��C��UBB代码的解析了�?
下面�l�出一个UBB�c?

/***************************UbbCode.java****************************************/
import java.util.regex.Matcher; //导入所需要的�c?br />import java.util.regex.Pattern;
public class UbbCode //�c�d��?br />{
private String source; //待�{化的HTML代码字符�?br />private String ubbTags[]; //UBB标记数组
private String htmlTags[]; //HTML标记数组

//初始�?分别为UBB标记数组和HTML标记数组赋�?br />public UbbCode()
{
byte byte0 = 74;
source = new String();
ubbTags = new String[byte0];
htmlTags = new String[byte0];
ubbTags[0] = "[b]";
htmlTags[0] = "";
ubbTags[1] = "[/b]";
htmlTags[1] = "";
ubbTags[2] = "[i]";
htmlTags[2] = "";
ubbTags[3] = "[/i]";
htmlTags[3] = "";
ubbTags[4] = "[quote]";
htmlTags[4] = "

";
ubbTags[5] = "[/quote]";
htmlTags[5] = "

";
ubbTags[6] = "[/size]";
htmlTags[6] = "";
ubbTags[7] = "[size=6]";
htmlTags[7] = "";
ubbTags[8] = "[size=8]";
htmlTags[8] = "";
ubbTags[9] = "[size=10]";
htmlTags[9] = "";
ubbTags[10] = "[size=12]";
htmlTags[10] = "";
ubbTags[11] = "[size=14]";
htmlTags[11] = "";
ubbTags[12] = "[size=18]";
htmlTags[12] = "";
ubbTags[13] = "[size=24]";
htmlTags[13] = "";
ubbTags[14] = "[size=36]";
htmlTags[14] = "";

//字体
ubbTags[15] = "[/font]";
htmlTags[15] = "";
ubbTags[16] = "[font=Arial]";
htmlTags[16] = "";
ubbTags[17] = "[font=Arial Black]";
htmlTags[17] = "";
ubbTags[18] = "[font=Verdana]";
htmlTags[18] = "";
ubbTags[19] = "[font=Times New Roman]";
htmlTags[19] = "";
ubbTags[20] = "[font=Garamond]";
htmlTags[20] = "";
ubbTags[21] = "[font=Courier New]";
htmlTags[21] = "";
ubbTags[22] = "[font=Webdings]";
htmlTags[22] = "";
ubbTags[23] = "[font=Wingdings]";
htmlTags[23] = "";
ubbTags[24] = "[font=隶书]";
htmlTags[24] = "";
ubbTags[25] = "[font=�q�圆]";
htmlTags[25] = "";
ubbTags[26] = "[font=�Ҏ��舒体]";
htmlTags[26] = "";
ubbTags[27] = "[font=�Ҏ��姚体]";
htmlTags[27] = "";
ubbTags[28] = "[font=仿宋_GB2312]";
htmlTags[28] = "";
ubbTags[29] = "[font=黑体]";
htmlTags[29] = "";
ubbTags[30] = "[font=华文彩云]";
htmlTags[30] = "";
ubbTags[31] = "[font=华文�l�黑]";
htmlTags[31] = "";
ubbTags[32] = "[font=华文新魏]";
htmlTags[32] = "";
ubbTags[33] = "[font=华文中宋]";
htmlTags[33] = "";
ubbTags[34] = "[font=华文行楷]";
htmlTags[34] = "";
ubbTags[35] = "[font=楷体_GB2312]";
htmlTags[35] = "";
ubbTags[36] = "[font=隶书]";
htmlTags[36] = "";
ubbTags[37] = "[font=华文楷体]";
htmlTags[37] = "";
ubbTags[38] = "[font=宋体]";
htmlTags[38] = "";
ubbTags[39] = "[font=新宋�?;
htmlTags[39] = "";
ubbTags[40] = "[font=�q�圆";
htmlTags[40] = "";

//字体颜色
ubbTags[41] = "[red]";
htmlTags[41] = "";
ubbTags[42] = "[/red]";
htmlTags[42] = "";
ubbTags[43] = "[blue]";
htmlTags[43] = "";
ubbTags[44] = "[/blue]";
htmlTags[44] = "";
ubbTags[45] = "[yellow]";
htmlTags[45] = "";
ubbTags[46] = "[/yellow]";
htmlTags[46] = "";
ubbTags[47] = "[green]";
htmlTags[47] = "";
ubbTags[48] = "[/green]";
htmlTags[48] = "";

ubbTags[49] = "[f]";
htmlTags[49] = "";

//标题
ubbTags[50] = "[h1]";
htmlTags[50] = "
";
ubbTags[51] = "[/h1]";
htmlTags[51] = "
";
ubbTags[52] = "[h2]";
htmlTags[52] = "
";
ubbTags[53] = "[/h2]";
htmlTags[53] = "
";
ubbTags[54] = "[h3]";
htmlTags[54] = "
";
ubbTags[55] = "[/h3]";
htmlTags[55] = "
";
ubbTags[56] = "[h4]";
htmlTags[56] = "
";
ubbTags[57] = "[/h4]";
htmlTags[57] = "
";
ubbTags[58] = "[h5]";
htmlTags[58] = "
";
ubbTags[59] = "[/h5]";
htmlTags[59] = "
";
ubbTags[60] = "[h6]";
htmlTags[60] = "
";
ubbTags[61] = "[/h6]";
htmlTags[61] = "
";
ubbTags[62] = "[hr]";
htmlTags[62] = "
";
ubbTags[63] = "[img]";
htmlTags[63] = "
ubbTags[64] = "[/img]";
htmlTags[64] = "\">
";
ubbTags[65] = "[center]";
htmlTags[65] = "
";
ubbTags[66] = "[/center]";
htmlTags[66] = "
";

ubbTags[67] = "[/f]";
htmlTags[67] = "
";
ubbTags[68] = "[left]";
htmlTags[68] = "

";
ubbTags[69] = "[/left]";
htmlTags[69] = "

";
ubbTags[70] = "[right]";
htmlTags[70] = "

";
ubbTags[71] = "[/right]";
htmlTags[71] = "

";
ubbTags[72] = "[u]";
htmlTags[72] = "";
ubbTags[73] = "[/u]";
htmlTags[73] = "";

}

private String replace(String s, String s1, String s2) {
StringBuffer stringbuffer = new StringBuffer();
for(int i = 0; i < s1.length(); i++) {
char c = s1.charAt(i);
switch(c) {
   case 91: // '['
    stringbuffer.append("\\[");
    break;

   case 93: // ']'
     stringbuffer.append("\\]");
     break;

   default:
     stringbuffer.append(c);
     break;
   }
}

Pattern pattern = Pattern.compile(stringbuffer.toString());
Matcher matcher = pattern.matcher(s);
StringBuffer stringbuffer1 = new StringBuffer();
for(boolean flag = matcher.find(); flag; flag = matcher.find())
matcher.appendReplacement(stringbuffer1, s2);

return matcher.appendTail(stringbuffer1).toString();
}

private String replaceNormalUBBCode(String s)
{
String s1 = new String(s);
for(int i = 0; i < ubbTags.length; i++)
s1 = replace(s1, ubbTags[i], htmlTags[i]);

return s1;
}

private String replaceURL(String s)
{
StringBuffer stringbuffer = new StringBuffer(s);
String s1 = new String();
int i = s.indexOf("[url]");
int j = s.indexOf("[/url]");
if(i != -1 && j != -1 && i < j)
{
String s2 = s.substring(i + 5, j);
String s3 = "" + s2 + "";
stringbuffer.replace(i, j + 6, s3);
}
return stringbuffer.toString();
}

private String replaceEmail(String s)
{
StringBuffer stringbuffer = new StringBuffer(s);
String s1 = new String();
int i = s.indexOf("[email]");
int j = s.indexOf("[/email]");
if(i != -1 && j != -1 && i < j)
{
String s2 = s.substring(i + 7, j);
String s3 = "" + s2 + "";
stringbuffer.replace(i, j + 8, s3);
}
return stringbuffer.toString();
}

public void setSource(String s)
{
source = s;
}

public String getResult()
{
return source;
}

public void run()
{
for(source = replaceNormalUBBCode(source); source.indexOf("[url]") != -1 && source.indexOf("[/url]") != -1;
source = replaceURL(source));
for(; source.indexOf("[email]") != -1 && source.indexOf("[/email]") != -1; source = replaceEmail(source));
}
}

何以解忧�Q�唯有学习！让每一个�h都能Open Source 2006-07-11 11:11 发表评论

JAVA中的指针,引用及对象的clone

何以解忧�Q�唯有学习！让每一个�h都能Open Source — Wed, 24 May 2006 12:03:00 GMT

看到�q�个标题�Q�是不是有点困惑�Q�Java语言明确说明取消了指针，因�ؓ指针往往是在带来方便的同时也是导致代码不安全的根源，同时也会使程序的变得非常复杂难以理解�Q�滥用指针写成的代码不亚于��用早已臭名昭著的"GOTO"语句。Java攑ּ�指针的概�늻��Ҏ��极其明智的。但�q�只是在Java语言中没有明��的指针定义�Q�实质上每一个new语句�q�回的都是一个指针的引用�Q�只不过在大多时候Java中不用关心如何操作这�?指针"�Q�更不用象在操作C�Q�＋的指针那栯��战心惊。唯一要多多关心的是在�l�函��C��递对象的时候。如下例�E�：

												
														package reference;
class Obj{
    String str = "init value";
    public String toString(){
        return str;
    }
}
public class ObjRef{
    Obj aObj = new Obj();
    int aInt = 11;
    public void changeObj(Obj inObj){
        inObj.str = "changed value";
    }
    public void changePri(int inInt){
        inInt = 22;
    }
    public static void main(String[] args) 
    {
        ObjRef oRef = new ObjRef();
        
        System.out.println("Before call changeObj() method: " + oRef.aObj);
        oRef.changeObj(oRef.aObj);
        System.out.println("After call changeObj() method: " + oRef.aObj);

        System.out.println("==================Print Primtive=================");
        System.out.println("Before call changePri() method: " + oRef.aInt);
        oRef.changePri(oRef.aInt);
        System.out.println("After call changePri() method: " + oRef.aInt);

    }
}

/* RUN RESULT
Before call changeObj() method: init value
After call changeObj() method: changed value
==================Print Primtive=================
Before call changePri() method: 11
After call changePri() method: 11

*
*/

�q�段代码的主要部分调用了两个很相�q�的�Ҏ��Q�changeObj()和changePri()。唯一不同的是它们一个把对象作�ؓ输入参数�Q�另一个把Java中的基本�c�d��int作�ؓ输入参数。�ƈ且在�q�两个函��C��内部都对输入的参数进行了改动。看��g��L��Ҏ��Q�程序输出的�l�果却不太一栗��changeObj()�Ҏ��真正的把输入的参数改变了�Q�而changePri()�Ҏ��对输入的参数没有��M��的改变�?/p>

从这个例子知道Java对对象和基本的数据类型的处理是不一��L��。和C语言一��P��当把Java的基本数据类型（如int�Q�char�Q�double�{�）作�ؓ入口参数传给函数体的时候，传入的参数在函数体内部变成了局部变量，�q�个局部变量是输入参数的一个拷贝，所有的函数体内部的操作都是针对�q�个拯��的操作，函数执行�l�束后，�q�个局部变量也��完成了它的使命�Q�它影响不到作�ؓ输入参数的变量。这�U�方式的参数传递被�U�Cؓ"��g��?。而在Java中用对象的作为入口参数的传递则�~�省�?引用传�?�Q�也��是说仅仅传递了对象的一�?引用"�Q�这�?引用"的概念同C语言中的指针引用是一��L��。当函数体内部对输入变量改变�Ӟ��实质上就是在对这个对象的直接操作�?/p>

除了在函��C��值的时候是"引用传�?�Q�在��M��?�Q?向对象变量赋值的时候都�?引用传�?。如�Q?/p>

												
														package reference;
class PassObj
{
    String str = "init value";
}
public class ObjPassValue 
{

    public static void main(String[] args) 
    {
        PassObj objA = new PassObj();
        PassObj objB = objA;

        objA.str = "changed in objA";
        System.out.println("Print objB.str value: " + objB.str);
    }
}
/* RUN RESULT
Print objB.str value: changed in objA
*/

�W�一句是在内存中生成一个新的PassObj对象�Q�然后把�q�个PassObj的引用赋�l�变量objA�Q�第二句是把PassObj对象的引用又赋给了变量objB。此时objA和objB是两个完全一致的变量�Q�以后�Q何对objA的改变都�{�同于对objB的改变�?/p>

即��明白了Java语言中的"指针"概念也许�q�会不经意间犯下面的错误�?/p>

Hashtable真的能存储对象吗�Q?/font>

看一看下面的很简单的代码�Q�先是声明了一个Hashtable和StringBuffer对象�Q�然后分四次把StriingBuffer对象攑օ�到Hashtable表中�Q�在每次攑օ�之前都对�q�个StringBuffer对象append()了一些新的字�W�串�Q?/p>

												
														package reference;
import java.util.*;
public class HashtableAdd{
    public static void main(String[] args){
        Hashtable ht = new Hashtable();
        StringBuffer sb = new StringBuffer();
        sb.append("abc,");
        ht.put("1",sb);     
        sb.append("def,");
        ht.put("2",sb);
        sb.append("mno,");
        ht.put("3",sb);
        sb.append("xyz.");
        ht.put("4",sb);
        
        int numObj=0;
        Enumeration it = ht.elements();
        while(it.hasMoreElements()){
            System.out.print("get StringBufffer "+(++numObj)+" from Hashtable: ");
            System.out.println(it.nextElement());
        }
    }
}

如果你认��出的�l�果是：
get StringBufffer 1 from Hashtable: abc,
get StringBufffer 2 from Hashtable: abc,def�Q?
get StringBufffer 3 from Hashtable: abc,def,mno,
get StringBufffer 4 from Hashtable: abc,def,mno,xyz.

那么你就要回�q�头再仔�l�看一看上一个问题了�Q�把对象时作为入口参��C��l�函敎ͼ�实质上是传递了对象的引用，向Hashtable传递StringBuffer对象也是只传递了�q�个StringBuffer对象的引用！每一�ơ向Hashtable表中put一�ơStringBuffer�Q��ƈ没有生成新的StringBuffer对象�Q�只是在Hashtable表中又放入了一个指向同一StringBuffer对象的引用而已�?/p>

对Hashtable表存储的��M��一个StringBuffer对象�Q�更��切的说应该是对象的引用�Q�的改动�Q�实际上都是对同一�?StringBuffer"的改动。所以Hashtable�q�不能真正存储能对象�Q�而只能存储对象的引用。也应该知道�q�条原则对与Hashtable�怼�的Vector, List, Map, Set�{�都是一��L��?/p>

上面的例�E�的实际输出的结果是�Q?/p>

												
														/* RUN RESULT
get StringBufffer 1 from Hashtable: abc,def,mno,xyz.
get StringBufffer 2 from Hashtable: abc,def,mno,xyz.
get StringBufffer 3 from Hashtable: abc,def,mno,xyz.
get StringBufffer 4 from Hashtable: abc,def,mno,xyz.
*/

回页�?/font>

�c�，对象与引�?/font>

Java最基本的概念就是类�Q�类包括函数和变量。如果想要应用类�Q�就要把�cȝ��成对象，�q�个�q�程被称�?�cȝ��实例�?。有几种�Ҏ��把类实例化成对象�Q�最常用的就是用"new"操作�W�。类实例化成对象后，��意味着要在内存中占据一块空间存攑֮�例。想要对�q�块�I�间操作��p��应用到对象的引用。引用在Java语言中的体现��是变量�Q�而变量的�c�d��是�q�个引用的对象。虽然在语法上可以在生成一个对象后直接调用该对象的函数或变量，如：

												
														new String("Hello NDP")).substring(0,3)　　//RETURN RESULT: Hel

但由于没有相应的引用�Q�对�q�个对象的��用也只能局限这条语句中了�?/p>

产生�Q�引用��L��在把对象作参�?传�?的过�E�中自动发生�Q�不需要�h为的产生�Q�也不能��Zؓ的控制引用的产生。这个传递包括把对象作�ؓ函数的入口参数的情况�Q�也包括�?�Q?�q�行对象赋值的时候�?
范围�Q�只有局部的引用�Q�没有局部的对象。引用在Java语言的体现就是变量，而变量在Java语言中是有范围的�Q�可以是局部的�Q�也可以是全局的�?
生存期：�E�序只能控制引用的生存周期。对象的生存期是由Java控制。用"new Object()"语句生成一个新的对象，是在计算机的内存中声明一块区域存储对象，只有Java的垃圾收集器才能军_��在适当的时候回收对象占用的内存�?
没有办法��L��对引用的改动�?

回页�?/font>

什么是"clone"�Q?/font>

在实际编�E�过�E�中�Q�我们常常要遇到�q�种情况�Q�有一个对象A�Q�在某一时刻A中已�l�包含了一些有效��|��此时可能会需要一个和A完全相同新对象B�Q��ƈ且此后对B��M��改动都不会媄响到A中的��|��也就是说�Q�A与B是两个独立的对象�Q�但B的初始值是由A对象��定的。在Java语言中，用简单的赋��D��句是不能满��q�种需求的。要满��q�种需求虽然有很多途径�Q�但实现clone�Q�）�Ҏ��是其中最��单，也是最高效的手�D�c�?/p>

Java的所有类都默认��承java.lang.Object�c�，在java.lang.Object�c�M��有一个方法clone()。JDK API的说明文档解释这个方法将�q�回Object对象的一个拷贝。要说明的有两点�Q�一是拷贝对象返回的是一个新对象�Q�而不是一个引用。二是拷贝对象与用new操作�W�返回的新对象的区别��是�q�个拯��已经包含了一些原来对象的信息�Q�而不是对象的初始信息�?/p>

回页�?/font>

怎样应用clone()�Ҏ��Q?/font>

一个很典型的调用clone()代码如下�Q?/p>

												
														class CloneClass implements Cloneable{
    public int aInt;
    public Object clone(){
        CloneClass o = null;
        try{
            o = (CloneClass)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return o;
    }
�?

有三个值得注意的地方，一是希望能实现clone功能的CloneClass�c�d��C��Cloneable接口�Q�这个接口属于java.lang包，java.lang包已�l�被�~�省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得��h��意的是重载了clone()�Ҏ��。最后在clone()�Ҏ��中调用了super.clone()�Q�这也意味着无论clone�cȝ��l�承�l�构是什么样的，super.clone()直接或间接调用了java.lang.Object�cȝ��clone()�Ҏ��。下面再详细的解释一下这几点�?/p>

应该说第三点是最重要的，仔细观察一下Object�cȝ��clone()一个native�Ҏ��Q�native�Ҏ��的效率一般来说都是远高于java中的非native�Ҏ��。这也解释了��Z��么要用Object中clone()�Ҏ��而不是先new一个类�Q�然后把原始对象中的信息赋到新对象中�Q�虽然这也实��C��clone功能。对于第二点�Q�也要观察Object�c�M��的clone()�q�是一个protected属性的�Ҏ��。这也意味着如果要应用clone()�Ҏ��Q�必��ȝ��承Object�c�，在Java中所有的�c�L��~�省�l�承Object�cȝ��Q�也��׃��用关心这点了。然后重载clone()�Ҏ��。还有一点要考虑的是��Z��让其它类能调用这个clone�cȝ��clone()�Ҏ��Q�重载之后要把clone()�Ҏ��的属性设�|��ؓpublic�?/p>

那么clone�c�Mؓ什么还要实现Cloneable接口呢？�E�微注意一下，Cloneable接口是不包含��M��Ҏ��的！其实�q�个接口仅仅是一个标志，而且�q�个标志也仅仅是针对Object�c�M��clone()�Ҏ��的，如果clone�c�L��有实现Cloneable接口�Q��ƈ调用了Object的clone()�Ҏ��Q�也��是调用了super.Clone()�Ҏ��Q�，那么Object的clone()�Ҏ��׃��抛出CloneNotSupportedException异常�?/p>

以上是clone的最基本的步骤，惌��完成一个成功的clone�Q�还要了解什么是"影子clone"�?深度clone"�?/p>

回页�?/font>

什么是影子clone�Q?/font>

下面的例子包含三个类UnCloneA�Q�CloneB�Q�CloneMain。CloneB�c�d��含了一个UnCloneA的实例和一个int�c�d��变量�Q��ƈ且重载clone()�Ҏ��。CloneMain�c�d��始化UnCloneA�cȝ��一个实例b1�Q�然后调用clone()�Ҏ��生成了一个b1的拷贝b2。最后考察一下b1和b2的输出：

												
														package clone;
class UnCloneA {
    private int i;
    public UnCloneA(int ii) { i = ii; }
    public void doubleValue() { i *= 2; }
    public String toString() {
        return Integer.toString(i);
    }
}
class CloneB implements Cloneable{
    public int aInt;
    public UnCloneA unCA = new UnCloneA(111);
    public Object clone(){
        CloneB o = null;
        try{
            o = (CloneB)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return o;
    }
}
public class CloneMain {
    public static void main(String[] a){
        CloneB b1 = new CloneB();
        b1.aInt = 11;
        System.out.println("before clone,b1.aInt = "+ b1.aInt);
        System.out.println("before clone,b1.unCA = "+ b1.unCA);
                
        CloneB b2 = (CloneB)b1.clone();
        b2.aInt = 22;
        b2.unCA.doubleValue();
        System.out.println("=================================");
        System.out.println("after clone,b1.aInt = "+ b1.aInt);
        System.out.println("after clone,b1.unCA = "+ b1.unCA);
        System.out.println("=================================");
        System.out.println("after clone,b2.aInt = "+ b2.aInt);
        System.out.println("after clone,b2.unCA = "+ b2.unCA);
    }
}


/** RUN RESULT:
before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 222
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222
*/

输出的结果说明int�c�d��的变量aInt和UnCloneA的实例对象unCA的clone�l�果不一��_��int�c�d��是真正的被clone了，因�ؓ改变了b2中的aInt变量�Q�对b1的aInt没有产生影响�Q�也��是��_��b2.aInt与b1.aInt已经占据了不同的内存�I�间�Q�b2.aInt是b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA�Q�很明显�Q�b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用�Q�从中可以看出，调用Object�c�M��clone()�Ҏ��产生的效果是�Q�先在内存中开辟一块和原始对象一��L��I�间�Q�然后原��h��贝原始对象中的内宏V��对基本数据�c�d��Q�这��L��操作是没有问题的�Q�但寚w��基本�c�d��变量�Q�我们知道它们保存的仅仅是对象的引用�Q�这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象�?/p>

大多时候，�q�种clone的结果往往不是我们所希望的结果，�q�种clone也被�U�Cؓ"影子clone"。要惌��b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作�ؓ初始信息�Q�就要实现深度clone�?/p>

回页�?/font>

怎么�q�行深度clone�Q?/font>

把上面的例子�Ҏ��深度clone很简单，需要两个改变：一是让UnCloneA�c�M��实现和CloneB�c�M��L��clone功能�Q�实现Cloneable接口�Q�重载clone()�Ҏ��Q�。二是在CloneB的clone()�Ҏ��中加入一句o.unCA = (UnCloneA)unCA.clone();

�E�序如下�Q?/p>

												
														package clone.ext;
class UnCloneA implements Cloneable{
    private int i;
    public UnCloneA(int ii) { i = ii; }
    public void doubleValue() { i *= 2; }
    public String toString() {
        return Integer.toString(i);
    }
    public Object clone(){
        UnCloneA o = null;
        try{
            o = (UnCloneA)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return o;
    }
}
class CloneB implements Cloneable{
    public int aInt;
    public UnCloneA unCA = new UnCloneA(111);
    public Object clone(){
        CloneB o = null;
        try{
            o = (CloneB)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        o.unCA = (UnCloneA)unCA.clone();
        return o;
    }
}
public class CloneMain {
    public static void main(String[] a){
        CloneB b1 = new CloneB();
        b1.aInt = 11;
        System.out.println("before clone,b1.aInt = "+ b1.aInt);
        System.out.println("before clone,b1.unCA = "+ b1.unCA);
                
        CloneB b2 = (CloneB)b1.clone();
        b2.aInt = 22;
        b2.unCA.doubleValue();
        System.out.println("=================================");
        System.out.println("after clone,b1.aInt = "+ b1.aInt);
        System.out.println("after clone,b1.unCA = "+ b1.unCA);
        System.out.println("=================================");
        System.out.println("after clone,b2.aInt = "+ b2.aInt);
        System.out.println("after clone,b2.unCA = "+ b2.unCA);
    }
}

/** RUN RESULT:
before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 111
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222
*/

可以看出�Q�现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例�Q�而且在CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的��|��在这里，b1.i = b2.i = 11�?/p>

要知道不是所有的�c�都能实现深度clone的。例如，如果把上面的CloneB�c�M��的UnCloneA�c�d��变量�Ҏ��StringBuffer�c�d��Q�看一下JDK API中关于StringBuffer的说明，StringBuffer没有重蝲clone()�Ҏ��Q�更��Z��重的是StringBuffer�q�是一个final�c�，�q�也是说我们也不能用�l�承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer�c�d��对象或和StringBuffer�怼��cȝ��对象�Q�我们有两种选择�Q�要么只能实现媄子clone�Q�要么就在类的clone()�Ҏ��中加一句（假设是SringBuffer对象�Q�而且变量名仍是unCA�Q�： o.unCA = new StringBuffer(unCA.toString()); //原来的是�Q�o.unCA = (UnCloneA)unCA.clone();

�q�要知道的是除了基本数据�c�d��能自动实现深度clone以外�Q�String对象是一个例外，它clone后的表现好象也实��C��深度clone�Q�虽然这只是一个假象，但却大大方便了我们的�~�程�?/p>

回页�?/font>

Clone中String和StringBuffer的区�?/font>

应该说明的是�Q�这里不是着重说明String和StringBuffer的区别，但从�q�个例子里也能看出String�cȝ��一些与众不同的地方�?/p>

下面的例子中包括两个�c�，CloneC�c�d��含一个String�c�d��变量和一个StringBuffer�c�d��变量�Q��ƈ且实��C��clone()�Ҏ��。在StrClone�c�M��声明了CloneC�c�d��变量c1�Q�然后调用c1的clone()�Ҏ��生成c1的拷贝c2�Q�在对c2中的String和StringBuffer�c�d��变量用相应的�Ҏ��改动之后打印�l�果�Q?/p>

												
														package clone;
class CloneC implements Cloneable{
    public String str;
    public StringBuffer strBuff;
    public Object clone(){
        CloneC o = null;
        try{
            o = (CloneC)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return o;
    }
    
}
public class StrClone {
    public static void main(String[] a){
        CloneC c1 = new CloneC();
        c1.str = new String("initializeStr");
        c1.strBuff = new StringBuffer("initializeStrBuff");
        System.out.println("before clone,c1.str = "+ c1.str);
        System.out.println("before clone,c1.strBuff = "+ c1.strBuff);
                
        CloneC c2 = (CloneC)c1.clone();
        c2.str = c2.str.substring(0,5);
        c2.strBuff = c2.strBuff.append(" change strBuff clone");
        System.out.println("=================================");
        System.out.println("after clone,c1.str = "+ c1.str);
        System.out.println("after clone,c1.strBuff = "+ c1.strBuff);
        System.out.println("=================================");
        System.out.println("after clone,c2.str = "+ c2.str);
        System.out.println("after clone,c2.strBuff = "+ c2.strBuff);
    }
}
/* RUN RESULT
before clone,c1.str = initializeStr
before clone,c1.strBuff = initializeStrBuff
=================================
after clone,c1.str = initializeStr
after clone,c1.strBuff = initializeStrBuff change strBuff clone
=================================
after clone,c2.str = initi
after clone,c2.strBuff = initializeStrBuff change strBuff clone
*
*/

打印的结果可以看出，String�c�d��的变量好象已�l�实��C��深度clone�Q�因为对c2.str的改动�ƈ没有影响到c1.str�Q�难道Java把Sring�cȝ��成了基本数据�c�d��Q�其实不�Ӟ��q�里有一个小��的把戏�Q�秘密就在于c2.str = c2.str.substring(0,5)�q�一语句�Q�实质上�Q�在clone的时候c1.str与c2.str仍然是引用，而且都指向了同一个String对象。但在执行c2.str = c2.str.substring(0,5)的时候，它作用相当于生成了一个新的String�c�d��Q�然后又赋回�l�c2.str。这是因为String被Sun公司的工�E�师写成了一个不可更改的�c�（immutable class�Q�，在所有String�c�M��的函数都不能更改自��n的倹{��下面给出很��单的一个例子：

package clone; public class StrTest { public static void main(String[] args) { String str1 = "This is a test for immutable"; String str2 = str1.substring(0,8); System.out.println("print str1 : " + str1); System.out.println("print str2 : " + str2); } } /* RUN RESULT print str1 : This is a test for immutable print str2 : This is */

例子中，虽然str1调用了substring()�Ҏ��Q�但str1的值�ƈ没有改变。类似的�Q�String�c�M��的其它方法也是如此。当然如果我们把最上面的例子中的这两条语句

												
														c2.str = c2.str.substring(0,5);
c2.strBuff = c2.strBuff.append(" change strBuff clone");

�Ҏ��下面�q�样�Q?/p>

												
														c2.str.substring(0,5);
c2.strBuff.append(" change strBuff clone");

��L��了重新赋值的�q�程�Q�c2.str也就不能有变化了�Q�我们的把戏也就露馅了。但在编�E�过�E�中只调�?/p>

												
														c2.str.substring(0,5);

语句是没有�Q何意义的�?/p>

应该知道的是在Java中所有的基本数据�c�d��都有一个相对应的类�Q�象Integer�c�d��应int�c�d��Q�Double�c�d��应double�c�d��{�等�Q�这些类也与String�cȝ��同，都是不可以改变的�c�R��也��是��_��q�些的类中的所有方法都是不能改变其自��n的值的。这也让我们在编clone�cȝ��时候有了一个更多的选择。同时我们也可以把自��q��cȝ��成不可更改的�c�R�?/p>

何以解忧�Q�唯有学习！让每一个�h都能Open Source 2006-05-24 20:03 发表评论

久草精品视频,久久一区二区三区喷水,色婷婷综合久久久

JavaEye三周�q�_��大家聊聊最喜欢的帖子一、你擦了吗？���定擦了�Q�真的确定擦了？

用JAVA实现UBB代码

";ubbTags[51] = "[/h1]";htmlTags[51] = "

";ubbTags[53] = "[/h2]";htmlTags[53] = "

";ubbTags[55] = "[/h3]";htmlTags[55] = "

";ubbTags[57] = "[/h4]";htmlTags[57] = "

";ubbTags[59] = "[/h5]";htmlTags[59] = "

";ubbTags[61] = "[/h6]";htmlTags[61] = "

JAVA中的指针,引用及对象的clone

JavaEye三周�q�_��大家聊聊最喜欢的帖子一、你擦了吗？��定擦了�Q�真的确定擦了？

";
ubbTags[51] = "[/h1]";
htmlTags[51] = "

";
ubbTags[53] = "[/h2]";
htmlTags[53] = "

";
ubbTags[55] = "[/h3]";
htmlTags[55] = "

";
ubbTags[57] = "[/h4]";
htmlTags[57] = "

";
ubbTags[59] = "[/h5]";
htmlTags[59] = "

";
ubbTags[61] = "[/h6]";
htmlTags[61] = "