ï»??xml version="1.0" encoding="utf-8" standalone="yes"?>性色视频在线,久九九久频精品短视频,91涩漫在线观看http://www.aygfsteel.com/alinglau36/category/38703.htmlone platform thousands thinkingzh-cnFri, 27 Oct 2017 22:21:12 GMTFri, 27 Oct 2017 22:21:12 GMT60newInstance() å’?new 有什么区别？(è½?http://www.aygfsteel.com/alinglau36/archive/2011/04/14/348306.htmllaulauThu, 14 Apr 2011 09:37:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2011/04/14/348306.htmlhttp://www.aygfsteel.com/alinglau36/comments/348306.htmlhttp://www.aygfsteel.com/alinglau36/archive/2011/04/14/348306.html#Feedback0http://www.aygfsteel.com/alinglau36/comments/commentRss/348306.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/348306.html 用newInstance与用new是区别的åQŒåŒºåˆ«åœ¨äºŽåˆ›å»ºå¯¹è±¡çš„方式不一æ øP¼Œå‰è€…是使用¾cÕdŠ è½½æœºåˆÓž¼Œé‚£ä¹ˆä¸ÞZ»€ä¹ˆä¼šæœ‰ä¸¤¿Uåˆ›å»ºå¯¹è±¡æ–¹å¼ï¼Ÿ˜q™ä¸ªž®Þp¦ä»Žå¯ä¼¸ç¾ƒã€å¯æ‰©å±•åQŒå¯é‡ç”¨½{‰èÊY件思想上解释了ã€?
Java中工厂模式经å¸æ€‹É用newInstance来创建对象，因此从äؓ什么要使用工厂模式上也可以扑ֈ°å…·ä½“½{”案ã€?
例如åQ?
Class c = Class.forName(“A”);factory = (AInterface)c.newInstance();
其中AInterface是A的接口，如果下面˜q™æ ·å†™ï¼Œä½ å¯èƒ½ä¼šç†è§£åQ?
String className = "A";Class c = Class.forName(className);factory = (AInterface)c.newInstance();
˜q›ä¸€æ­¥ï¼Œå¦‚果下面写，你可能会理解åQ?
String className = readfromXMlConfig;//从xml 配置文äšg中获得字½W¦ä¸²Class c = Class.forName(className);factory = (AInterface)c.newInstance();
上面代码ž®±æ¶ˆç­äº†A¾cÕd¿UŽÍ¼Œä¼˜ç‚¹åQšæ— è®ºA¾cÀL€Žä¹ˆå˜åŒ–åQŒä¸Š˜qîC»£ç ä¸å˜ï¼Œç”šè‡³å¯ä»¥æ›´æ¢A的兄弟类B , C , D....½{‰ï¼Œåªè¦ä»–们¾l§æ‰¿Ainterfacež®±å¯ä»¥ã€?
从jvm的角度看åQŒæˆ‘们ä‹É用new的时候，˜q™ä¸ªè¦new的类可以没有加蝲åQ?
但是使用newInstance时候，ž®±å¿…™åÖM¿è¯ï¼š1、这个类已经加蝲åQ?、这个类已经˜qžæŽ¥äº†ã€‚而完成上面两个步骤的正是class的静态方法forNameåQˆï¼‰æ–ÒŽ³•åQŒè¿™ä¸ªé™æ€æ–¹æ³•è°ƒç”¨äº†å¯åŠ¨¾cÕdŠ è½½å™¨åQˆå°±æ˜¯åŠ è½½java API的那个加载器åQ?/span>ã€?
有了上面jvm上的理解åQŒé‚£ä¹ˆæˆ‘们可以这栯‚¯´åQŒnewInstance实际上是把new˜q™ä¸ªæ–¹å¼åˆ†è§£ä¸ÞZ¸¤æ­?卻I¼Œé¦–先调用class的加载方法加载某个类åQŒç„¶åŽå®žä¾‹åŒ–ã€?
˜q™æ ·åˆ†æ­¥çš„好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灉|´»æ€§ï¼Œæä¾›¾l™äº†æˆ‘们降耦的手段ã€?

[补充:]
newInstance: å¼Þq±»åž‹ã€‚低效率。只能调用无参构造ã€?
new: 强类型。相寚w«˜æ•ˆã€‚能调用ä»ÖM½•public构造ã€?
newInstance()是实现IOC、反ž®„、面å¯ÒŽŽ¥å£ç¼–½E?å’?依赖倒置 ½{‰æŠ€æœ¯æ–¹æ³•çš„必然选择åQŒnew 只能实现具体¾cȝš„实例化，不适合于接口编½E‹ã€?
里面ž®±æ˜¯é€šè¿‡˜q™ä¸ª¾cȝš„默认构造函数构å»ÞZº†ä¸€ä¸ªå¯¹è±¡ï¼Œå¦‚果没有默认构造函数就抛出InstantiationException, 如果没有讉K—®é»˜è®¤æž„造函数的权限ž®±æŠ›å‡ºIllegalAccessException

]]>Java正则表达å¼?/title><link>http://www.aygfsteel.com/alinglau36/archive/2010/10/11/334448.html</link><dc:creator>lau</dc:creator><author>lau</author><pubDate>Mon, 11 Oct 2010 08:41:00 GMT</pubDate><guid>http://www.aygfsteel.com/alinglau36/archive/2010/10/11/334448.html</guid><wfw:comment>http://www.aygfsteel.com/alinglau36/comments/334448.html</wfw:comment><comments>http://www.aygfsteel.com/alinglau36/archive/2010/10/11/334448.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.aygfsteel.com/alinglau36/comments/commentRss/334448.html</wfw:commentRss><trackback:ping>http://www.aygfsteel.com/alinglau36/services/trackbacks/334448.html</trackback:ping><description><![CDATA[<p>ž®çŸ¥è¯†ï¼š{}　定义了一个范围　 [] 定义了一个字½W¦ç±»ã€€() 定义了一个组 <br /> *前面出现0‹Æ¡ä»¥ä¸?nbsp;  +　前面匚w…ä¸€‹Æ¡ä»¥ä¸Šã€€?前面出现0‹Æ¡æˆ–一‹Æ?/p> <p><br /> <span style="font-size: medium; color: #0000ff;">1).字符åQ?/span> <br /> x------字符x <br /> ""-----反斜æ?<br /> "0n----十进制数 (0 <= n <= 7) <br /> "0nn---十进制数0nn (0 <= n <= 7) <br /> "0mnn--十进制数0mnn (0 <= m <= 3,0 <= n <= 7) <br /> "xhh---十六˜q›åˆ¶æ•?0xhh <br /> ""uhhh-十六˜q›åˆ¶æ•?0uhhh <br /> "t-----制表½W?('"u0009') 2) <br /> "n-----换行½W?('"u000A') <br /> "r----- 回èžR½W?('"u000D') <br /> "e----- esc½W¦å· ('"u001B') <br /> "cx---- x 对应的控制符 <br /> <span style="font-size: medium; color: #0000ff;">2).字符¾c»ï¼š </span><br /> [abc] a, b, æˆ?c (½Ž€å•å­—½W¦ä¸²) <br /> [^abc] 除了 a, b, æˆ?c 之外的ä“Q意字½W?否定) <br /> [a-zA-Z] 从a åˆ?z æˆ?从A åˆ?ZåQˆåŒ…括a,z,A,ZåQ?范围) <br /> [a-d[m-p]] 从a åˆ?d, æˆ?从m åˆ?p: [a-dm-p] (òq‰™›†) <br /> [a-z&&[def]] d, e, æˆ?f (交集) <br /> [a-z&&[^bc]] 从a åˆ?z, ä½?b å’?c 除外: [ad-z] (子集) <br /> [a-z&&[^m-p]] 从a åˆ?z, 不包括从 m åˆ?p: [a-lq-z](子集) <br /> <span style="font-size: medium; color: #0000ff;">3).预定义字½W¦åºåˆ?:</span> <br /> . ä»ÀL„å­—符 (也可能不包括行结束符) <br /> "d æ•°å­—: [0-9] <br /> "D 非数å­? [^0-9] <br /> "s ½Iºå­—½W? [ "t"n"x0B"f"r](A whitespace character) <br /> "S 非空字符: [^"s] <br /> "w 单字字符: [a-zA-Z_0-9] <br /> "W 非单字字½W? [^"w] <br /> <span style="font-size: medium; color: #0000ff;">4).POSIX 字符¾c?(US-ASCII only) :</span> <br /> "p{Lower} ž®å†™å­—母字符: [a-z] <br /> "p{Upper} 大写字母字符:[A-Z] <br /> "p{ASCII} 所æœ?ASCII:["x00-"x7F] <br /> "p{Alpha} 单个字母字符:["p{Lower}"p{Upper}] <br /> "p{Digit} 十进制数: [0-9] <br /> "p{Alnum} 单个字符:["p{Alpha}"p{Digit}] <br /> "p{Punct} 标点½W¦å·: 包括 !"#$%&'()*+,-./:;<=>?@["]^_`{|}~ <br /> "p{Graph} 可视字符: ["p{Alnum}"p{Punct}] <br /> "p{Print} 可打印字½W? ["p{Graph}] <br /> "p{Blank} ½Iºæ ¼æˆ–制表符: [ "t] <br /> "p{Cntrl} 控制字符: ["x00-"x1F"x7F] <br /> "p{XDigit} 十六˜q›åˆ¶æ•? [0-9a-fA-F] <br /> "p{Space} ½Iºå­—½W? [ "t"n"x0B"f"r] <br /> <span style="font-size: medium; color: #0000ff;">5). Unicode 字符¾c?</span> <br /> "p{InGreek} 希腊语种的字½W?(simple block) <br /> "p{Lu} 大写字母 (simple category) <br /> "p{Sc} 货币½W¦å· <br /> "P{InGreek} 除希腊语¿Uå­—½W¦å¤–çš„ä“Q意字½W?(negation) <br /> ["p{L}&&[^"p{Lu}]] 除大写字母外的ä“Q意字½W?(subtraction) <br /> <span style="font-size: medium; color: #0000ff;">6). 边界匚w…å™?</span> <br /> ^ 一行的开å§?<br /> $ 一行的¾l“束 <br /> "b 单词边界 <br /> "B 非单词边ç•?<br /> "A 输入的开å§?<br /> "G 当前匚w…çš„结æ?<br /> "Z The end of the input but for the final terminator, if any <br /> "z 输入的结æ?<br /> <span style="font-size: medium; color: #0000ff;">6).Greedy quantifiers 贪婪匚w…é‡è¯:</span> <br /> X? X不出现或出现一‹Æ?(ç‰ÒŽ®Šå­—符"?"与{0,1}是相½{‰çš„) <br /> X* X不出现或出现多次 (ç‰ÒŽ®Šå­—符"*"与{0,}是相½{‰çš„) <br /> X+ X臛_°‘出现一‹Æ?(ç‰ÒŽ®Šå­—符"+"ä¸?{1,}是相½{‰çš„) <br /> X{n} X出现n‹Æ?<br /> X{n,} X臛_°‘出现n‹Æ?<br /> X{n,m} X臛_°‘出现n‹Æ¡ï¼Œä½†ä¸ä¼šè¶…˜q‡m‹Æ?<br /> <span style="font-size: medium; color: #0000ff;">7).Reluctant quantifiers:</span> <br /> X?? X, 不出现或出现一‹Æ?<br /> X*? X, 不出现或出现多次 <br /> X+? X, 臛_°‘出现一‹Æ?<br /> X{n}? X, 出现n‹Æ?<br /> X{n,}? X, 臛_°‘出现n‹Æ?<br /> X{n,m}? X, 臛_°‘出现n‹Æ¡ï¼Œä½†ä¸ä¼šè¶…˜q‡m‹Æ?<br /> <span style="font-size: medium; color: #0000ff;">8).Possessive quantifiers:</span> <br /> X?+ X, 不出现或出现一‹Æ?<br /> X*+ X, 不出现或出现多次 <br /> X++ X, 臛_°‘出现一‹Æ?<br /> X{n}+ X, 出现n‹Æ?<br /> X{n,}+ X, 臛_°‘出现n‹Æ?<br /> X{n,m}+ X, 臛_°‘出现n‹Æ¡ï¼Œä½†ä¸ä¼šè¶…˜q‡m‹Æ?<br /> <span style="font-size: medium; color: #0000ff;">9).逻辑˜qç®—½W?</span> <br /> XY Y跟在X后面 <br /> X|Y X æˆ?Y <br /> (X) X, as a capturing group <br /> <span style="font-size: medium; color: #0000ff;">10).反向引用:</span> <br /> "n Whatever the nth capturing group matched <br /> <span style="font-size: medium; color: #0000ff;">11).Quotation:</span> <br /> " 引用后面的字½W?<br /> "Q 引用所有的字符直到 "E 出现 <br /> "E ¾l“束ä»?"Q 开始的引用 <br /> <span style="font-size: medium; color: #0000ff;">12).Special constructs (non-capturing):</span> <br /> (?:X) X, as a non-capturing group <br /> (?idmsux-idmsux) 匚w…æ ‡å¿—å¼€å…?<br /> (?idmsux-idmsux:X) X, as a non-capturing group with the given flags on <br /> (?=X) X, via zero-width positive lookahead - off <br /> (?!X) X, via zero-width negative lookahead <br /> (? <=X) X, via zero-width positive lookbehind <br /> (?(? > X) X, as an independent, non-capturing group </p> <hr /> <p><br /> <span style="font-size: medium; color: #0000ff;">1).Backslashes, escapes, and quoting</span> <br /> å? 斜杠字符('"')用来转义åQŒå°±åƒä¸Šé¢çš„表中定义的那æ øP¼Œå¦‚果不这样做的话可能会äñ”ç”?歧义。因此，表达å¼?"匚w… 单个反斜杠，表达å¼?{匚w…å•ä¸ªå·¦èŠ±æ‹¬å·ã€?如果把反斜杠攑֜¨æ²¡æœ‰å®šä¹‰è½¬ç§»æž„造的ä»ÖM½•å­—母½W¦å·å‰é¢éƒ½ä¼šå‘生错误åQŒè¿™äº›å°†è¢«ä¿ç•? åˆîC»¥åŽçš„正则表达式中扩展。反斜杠可以攑֜¨ä»ÖM½• 非字母符号前面，即ä‹É它没有定义è{义构造也不会发生错误ã€? 在java语言规范中指出，在java代码中自½W¦ä¸²ä¸­çš„反斜杠是必要的，不管用于Unicodeè½?义，˜q˜æ˜¯ç”¨äºŽæ™®é€šçš„字符转义。因此， ä¸ÞZº†ä¿æŒæ­£åˆ™è¡¨è¾¾å¼çš„完整性，在java字符串中要写两个反斜杠。例如，在正则表辑ּ 中字½W?"b'代表退æ û|¼Œ'""b'则代表单词边界ã€?"(hello")'是无效的åQŒåƈ且会产生¾~–译 æ—‰™”™è¯¯ï¼Œä½ å¿…™åȝ”¨ '""(hello"")'来匹é…?hello)ã€?<br /> <span style="font-size: medium; color: #0000ff;">2).Character Classes</span> <br /> 字符¾cÕd¯ä»¥å‡ºçŽ°åœ¨å…¶ä»–字符¾cÕd†…部，òq¶ä¸”可以由åƈ操作½W¦å’Œä¸Žæ“ä½œç¬¦(&&)¾l„成。åƈ集操 作结果是åQŒå…¶ä¸­çš„ä»ÀL„å­—符åQŒè‚¯å®šåœ¨è‡›_°‘其中操作æ•îC¸­è‡›_°‘出现˜q‡ä¸€‹Æ¡ã€?交集的结果包括各个操作数中同时出现的ä»ÀL„å­—符ã€?<br /> 字符¾cÀL“ä½œç¬¦çš„优先çñ”如下åQšï¼ˆä»Žé«˜åˆîC½ŽåQ?<br /> 1 文字转义 "x <br /> 2 集合 [...] <br /> 3 范围 a-z <br /> 4 òq‰™›† [a-e][i-u] <br /> 5 交集 [a-z&&[aeiou]] <br /> è¯äh³¨æ„å„个字½W¦ç±»çš„有效字½W¦é›†ã€‚例如，在字½W¦ç±»ä¸­ï¼Œæ­£åˆ™è¡¨è¾¾å¼?失去了它的特别含ä¹?åQŒè€?变成了元字符的范围指½Cºã€?<br /> <span style="font-size: medium; color: #0000ff;">3).Line terminators</span> <br /> 行结束符是一个或两个字符序列åQŒç”¨æ¥æ ‡è¯†è¾“入字½W¦åºåˆ—的一行的¾l“束。下列都被认ä¸?是行¾l“束½W¦ï¼š <br /> 换行½W?('"n'), <br /> 回èžR换行½W?(""r"n"), <br /> 回èžR½W?('"r'), <br /> 下一è¡?('"u0085'), <br /> 行分隔符 ('"u2028'), 或段分隔½W?('"u2029). <br /> 如果‹È€‹zÖMº† UNIX_LINES 模式åQŒå”¯ä¸€çš„è¡Œ¾l“束½W¦å°±æ˜¯æ¢è¡Œç¬¦ã€?<br /> 除非你指定了 DOTALL 标志åQŒå¦åˆ™æ­£åˆ™è¡¨è¾‘Ö¼.匚w…ä»ÖM½•å­—符åQŒåªæœ‰è¡Œ¾l“束½W¦é™¤å¤–ã€?<br /> ¼‹®çœæƒ…况æ—Óž¼Œåœ¨æ•´ä¸ªè¾“入队列中åQŒæ­£åˆ™è¡¨è¾‘Ö¼^å’?忽略行结束符åQŒåªåŒšw…å¼€å§‹å’Œ¾l“束ã€?<br /> 如果‹È€‹zÖMº† MULTILINE 模式åQŒåˆ™^匚w…è¾“入的开始和所有行¾l“束½W¦ä¹‹åŽï¼Œé™¤äº†æ•´ä¸ªè¾“å…¥ 的结束ã€?<br /> 在MULTILINE 模式下，$匚w…æ‰€æœ‰è¡Œ¾l“束½W¦ä¹‹å‰ï¼Œå’Œæ•´ä¸ªè¾“入的¾l“束ã€?<br /> </p> <p><span style="font-size: medium; color: #0000ff;">4).Groups and capturing</span> <br /> 分组捕获通过从左到右的顺序，æ ÒŽ®æ‹¬å·çš„数量类排序。例如，在表辑ּ((A)(B(C)))中，有四个组åQ?<br /> 1     ((A)(B(C))) <br /> 2     (A) <br /> 3     (B(C)) <br /> 4     (C) <br /> 0¾l„代表整个表辑ּã€?<br /> åˆ? ¾l„捕获之所以如此命名，是因为在匚w…˜q‡ç¨‹ä¸­ï¼Œè¾“入序列的每一个与分组匚w…çš„子åº? 列都会被保存èµäh¥ã€‚通过向后引用åQŒè¢«æ•èŽ·çš„子序列可以在后面的表达式中被再‹Æ¡ä‹É用。而且åQŒåœ¨åŒšw…æ“ä½œ¾l“束以后˜q˜å¯ä»¥é€šè¿‡åŒšw…å™¨é‡æ–°æ‰¾åˆ°ã€‚与一个分¾l„关联的 被捕获到的输入通常是被保存的最˜q‘与˜q™ä¸ªåˆ†ç»„相匹配的队列的子队列。如果一个分¾l„被½W¬äºŒ‹Æ¡æ±‚å€û|¼Œå³ä‹Éå¤ÞpÓ|åQŒå®ƒçš„上一‹Æ¡è¢«æ•èŽ·çš„å€ég¹Ÿä¼šè¢«ä¿å­˜èµäh¥ã€?<br /> 例如åQŒè¡¨è¾‘Ö¼(a(b)?)+匚w…"aba"åQ?b"设äؓ子分¾l„。在开始匹配的时候，以前被捕èŽïLš„输入都将被清除。以(?开始的分组是完全的åQŒæ— éœ€æ•èŽ·çš„分¾l„不会捕获ä“Q何文本，也不会计½Ž—分¾l„æ€ÀL•°ã€?/p> <p><span style="font-size: medium; color: #0000ff;">5).Unicode support</span> <br /> <br /> Unicode Technical Report #18: Unicode Regular Expression Guidelines通过è½Õd¾®çš„语法改变实çŽîCº†æ›´æ·±å±‚次的支持ã€?<br /> 在java代码中，åƒ?u2014 ˜q™æ ·çš„è{义序列，java语言规范中？3.3提供了处理方æ³?ã€?<br /> ä¸ÞZº†ä¾¿äºŽä½¿ç”¨ä»Žæ–‡ä»¶æˆ–键盘è¯Õd–çš„unicode转义字符åQŒæ­£åˆ™è¡¨è¾‘Ö¼è§£æžå™¨ä¹Ÿç›´æŽ¥å®žçŽ°äº†è¿™¿Uè{¿U…R€‚因此，字符ä¸?"u2014"ä¸?""u2014"虽然不相½{‰ï¼Œä½†æ˜¯¾~–译˜q›åŒä¸€¿Uæ¨¡å¼ï¼Œå¯ä»¥åŒšw…åå…­˜q›åˆ¶æ•?x2014ã€?<br /> åœ? Perl中，unicode块和分类被写å…?p,"P。如果输入有prop属性，"p{prop}ž®†ä¼šåŒšw…åQ? è€?P{prop}ž®†ä¸ä¼šåŒ¹é…ã€‚块通过前缀In指定åQŒä½œä¸ºåœ¨nMongolian之中。分¾c»é€šè¿‡ä»ÀL„çš„前¾~€Is指定åQ?"p{L} å’?"p{IsL} 都引ç”?Unicode 字母。块和分¾cÕd¯ä»?被ä‹É用在字符¾cȝš„内部或外部ã€?<br />   <br /> The Unicode Standard, Version 3.0指出了支持的块和分类。块的名字在½W?4ç« å’Œ Unicode CharacterDatabase中的 Blocks-3.txt æ–‡äšg定义åQŒä½†½Iºæ ¼è¢«å‰”除了。例如Basic Latin"变成äº?nbsp; "BasicLatin"。分¾cȝš„名字被定义在88™åµï¼Œè¡?-5ã€?/p> <img src ="http://www.aygfsteel.com/alinglau36/aggbug/334448.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.aygfsteel.com/alinglau36/" target="_blank">lau</a> 2010-10-11 16:41 <a href="http://www.aygfsteel.com/alinglau36/archive/2010/10/11/334448.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>关于数组和List之间ç›æ€º’转换的方æ³?/title><link>http://www.aygfsteel.com/alinglau36/archive/2010/04/02/317278.html</link><dc:creator>lau</dc:creator><author>lau</author><pubDate>Fri, 02 Apr 2010 03:24:00 GMT</pubDate><guid>http://www.aygfsteel.com/alinglau36/archive/2010/04/02/317278.html</guid><wfw:comment>http://www.aygfsteel.com/alinglau36/comments/317278.html</wfw:comment><comments>http://www.aygfsteel.com/alinglau36/archive/2010/04/02/317278.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.aygfsteel.com/alinglau36/comments/commentRss/317278.html</wfw:commentRss><trackback:ping>http://www.aygfsteel.com/alinglau36/services/trackbacks/317278.html</trackback:ping><description><![CDATA[<h1> <a id="ctl04_TitleUrl" class="postTitle2" >关于数组和List之间ç›æ€º’转换的方æ³?/a> </h1> <p>1.List转换成äؓ数组。（˜q™é‡Œçš„List是实体是ArrayList) </p> <p>调用ArrayListçš„toArrayæ–ÒŽ³•ã€?</p> <p>toArray </p> <p>public T[] toArray(T[] a)˜q”回一个按照正¼‹®çš„™åºåºåŒ…含此列表中所有元素的数组åQ›è¿”回数¾l„çš„˜qè¡Œæ—¶ç±»åž‹å°±æ˜¯æŒ‡å®šæ•°¾l„çš„˜qè¡Œæ—¶ç±»åž‹ã€‚如果列表能攑օ¥æŒ‡å®šçš„æ•°¾l„，则返回放入此列表å…? 素的数组。否则，ž®†æ ¹æ®æŒ‡å®šæ•°¾l„çš„˜qè¡Œæ—¶ç±»åž‹å’Œæ­¤åˆ—表的大小分配一个新的数¾l„ã€?</p> <p>如果指定的数¾l„能容纳列表òq¶æœ‰å‰©ä½™½Iºé—´åQˆå³æ•°ç»„的元素比列表的多åQ‰ï¼Œé‚£ä¹ˆä¼šå°†æ•°ç»„中紧跟在集合末尾的元素设¾|®äØ“ null。这对确定列表的长度很有用，但只 在调用方知道列表中不包含ä»ÖM½• null 元素时才有用ã€?</p> <p>指定者： </p> <p>接口 Collection 中的 toArray </p> <p>指定者： </p> <p>接口 List 中的 toArray </p> <p>覆盖åQ?</p> <p>¾c?AbstractCollection 中的 toArray </p> <p>参数åQ?</p> <p>a - 要存储列表元素的数组åQŒå¦‚果它­‘›_¤Ÿå¤§çš„话；否则åQŒå®ƒæ˜¯ä¸€ä¸ªäؓ存储列表元素而分配的、具有相同运行时¾cÕdž‹çš„新数组ã€?</p> <p>˜q”回åQ?</p> <p>包含列表元素的数¾l„ã€?</p> <p>抛出åQ?</p> <p>ArrayStoreException - 如果 a 的运行时¾cÕdž‹ä¸æ˜¯æ­¤åˆ—表中每个元素的运行时¾cÕdž‹çš„超¾cÕdž‹ã€?</p> <p><br /> 具体用法åQ?</p> <p>List list = new ArrayList(); </p> <p>list.add("1"); </p> <p>list.add("2"); </p> <p>final int size = list.size(); </p> <p>String[] arr = (String[])list.toArray(new String[size]); </p> <p><br /> 2.数组转换成äØ“Listã€?</p> <p>调用Arraysçš„asListæ–ÒŽ³•. </p> <p>asList </p> <p>public static List asList(T... a)˜q”回一个受指定数组支持的固定大ž®çš„列表。（对返回列表的更改ä¼?#8220;直写”到数¾l„。）此方法同 Collection.toArray 一èµøP¼Œå……当了基于数¾l„çš„ API 与基äº?collection çš?API 之间的桥梁。返回的列表是可序列化的åQŒåƈ且实çŽîCº† RandomAccessã€?</p> <p>此方法还提供了一个创建固定长度的列表的便æäh–¹æ³•ï¼Œè¯¥åˆ—表被初始化äؓ包含多个元素åQ?</p> <p><br /> List stooges = Arrays.asList("Larry", "Moe", "Curly"); </p> <p><br /> 参数åQ?</p> <p>a - 支持列表的数¾l„ã€?</p> <p>˜q”回åQ?</p> <p>指定数组的列表视图ã€?</p> <p>另请参见åQ?</p> <p>Collection.toArray() </p> <p><br /> 具体用法: </p> <p>String[] arr = new String[] {"1", "2"}; </p> <p>List list = Arrays.asList(arr);  </p> <p>-------------------------------------------------------------------------------------------------------------------------------</p> <p><strong>Arrays.asList is a feature every Java developer should know about. It'll save you from writing code like:</strong></p> <p><strong>List<Foo> foolist = new ArrayList<Foo>();<br /> foolist.add(foo);<br /> return foolist;</strong></p> <p><strong>or maybe</strong></p> <p><strong>if(map.containsKey(id)){<br />       map.get(id).add(foo);<br /> }else{<br />       List<Foo> foolist = new ArrayList<Foo>();<br />       foolist.add(foo);<br />       map.put(id, foo);<br /> }</strong></p> <p><strong>and allow you to write code like:</strong></p> <p><strong>return Arrays.asList(foo);</strong></p> <p><strong>and</strong></p> <p><strong>if(map.containsKey(id))<br />       map.get(id).add(foo);<br /> else<br />       map.put(id, Arrays.asList(foo));</strong></p> <p><strong>Update: I didn't notice that Arrays.asList returns a List that can't be added too. When you try to call add on the returned List, you'll get an UnsupportedOperationException in AbstractList.add. That seemed lame to me, but the List interface does say that add is an "optional operation". For the lists to be mutable, the above code snippets have to be changed to something like:</strong></p> <p><strong>return new ArrayList<Foo>(Arrays.asList(foo));</strong></p> <p><strong>and</strong></p> <p><strong>if(map.containsKey(id))<br />       map.get(id).add(foo);<br /> else<br />       map.put(id, new ArrayList<Foo>(Arrays.asList(foo)));</strong></p> <p><strong>Update: Of course, the more pathalogical example of what Arrays.asList saves you from is:</strong></p> <p><strong>List<Foo> foolist = new ArrayList<Foo>(fooarray.length);<br /> for(int i=0,n=fooarray.length; i<n; i++){<br />       foolist.add(fooarray[i]);<br /> }</strong></p> <p><strong>or</strong></p> <p><strong>List<Foo> foolist = new ArrayList<Foo>(fooarray.length);<br /> for(Foo f : fooarray){<br />       foolist.add(f);<br /> }</strong></p> <p><strong>because that becomes just:</strong></p> <p><strong>List<Foo> foolist = Arrays.asList(fooarray);</strong></p> <img src ="http://www.aygfsteel.com/alinglau36/aggbug/317278.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.aygfsteel.com/alinglau36/" target="_blank">lau</a> 2010-04-02 11:24 <a href="http://www.aygfsteel.com/alinglau36/archive/2010/04/02/317278.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>错误汇æ€?/title><link>http://www.aygfsteel.com/alinglau36/archive/2010/03/31/317100.html</link><dc:creator>lau</dc:creator><author>lau</author><pubDate>Wed, 31 Mar 2010 14:11:00 GMT</pubDate><guid>http://www.aygfsteel.com/alinglau36/archive/2010/03/31/317100.html</guid><wfw:comment>http://www.aygfsteel.com/alinglau36/comments/317100.html</wfw:comment><comments>http://www.aygfsteel.com/alinglau36/archive/2010/03/31/317100.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.aygfsteel.com/alinglau36/comments/commentRss/317100.html</wfw:commentRss><trackback:ping>http://www.aygfsteel.com/alinglau36/services/trackbacks/317100.html</trackback:ping><description><![CDATA[<strong>4.5. é”™è¯¯</strong><br /> <br /> java.lang.AbstractMethodError<br /> <br /> 抽象æ–ÒŽ³•é”™è¯¯ã€‚当应用试图调用抽象æ–ÒŽ³•æ—¶æŠ›å‡ºã€?br /> <br /> java.lang.AssertionError<br /> <br /> 断言错。用来指½CÞZ¸€ä¸ªæ–­­a€å¤ÞpÓ|的情å†üc€?br /> <br /> java.lang.ClassCircularityError<br /> <br /> ¾cÕdó@环依赖错误。在初始化一个类æ—Óž¼Œè‹¥æ£€‹¹‹åˆ°¾cÖM¹‹é—´åó@环依赖则抛出该异常ã€?br /> <br /> java.lang.ClassFormatError<br /> <br /> ¾cÀL ¼å¼é”™è¯¯ã€‚当Java虚拟æœø™¯•å›¾ä»Žä¸€ä¸ªæ–‡ä»¶ä¸­è¯Õd–Java¾c»ï¼Œè€Œæ£€‹¹‹åˆ°è¯¥æ–‡ä»¶çš„内容不符合类的有效格式时抛出ã€?br /> <br /> java.lang.Error<br /> <br /> 错误。是所有错误的基类åQŒç”¨äºŽæ ‡è¯†ä¸¥é‡çš„½E‹åº˜qè¡Œé—®é¢˜ã€‚这些问题通常描述一些不应被应用½E‹åºæ•èŽ·çš„反常情å†üc€?br /> <br /> java.lang.ExceptionInInitializerError<br /> <br /> 初始化程序错误。当执行一个类的静态初始化½E‹åºçš„过½E‹ä¸­åQŒå‘生了异常时抛出。静态初始化½E‹åºæ˜¯æŒ‡ç›´æŽ¥åŒ…含于类中的static语句ŒDüc€?br /> <br /> java.lang.IllegalAccessError<br /> <br /> ˜qæ³•è®‰K—®é”™è¯¯ã€‚当一个应用试图访问、修æ”ÒŽŸä¸ªç±»çš„域åQˆFieldåQ‰æˆ–者调用其æ–ÒŽ³•åQŒä½†æ˜¯åˆ˜qååŸŸæˆ–æ–ÒŽ³•çš„可见性声明，则抛å‡ø™¯¥å¼‚常ã€?br /> <br /> java.lang.IncompatibleClassChangeError<br /> <br /> 不兼容的¾cÕd˜åŒ–错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时åQŒæŠ›å‡ø™¯¥å¼‚常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新¾~–译而直接运行的情况下，å®ÒŽ˜“引发该错误ã€?br /> <br /> java.lang.InstantiationError<br /> <br /> 实例化错误。当一个应用试å›ùN€šè¿‡Javaçš„new操作½W¦æž„造一个抽象类或者接口时抛出该异å¸?<br /> <br /> java.lang.InternalError<br /> <br /> 内部错误。用于指½CºJava虚拟机发生了内部错误ã€?br /> <br /> java.lang.LinkageError<br /> <br /> 链接错误。该错误及其所有子¾cÀLŒ‡½CºæŸä¸ªç±»ä¾èµ–于另外一些类åQŒåœ¨è¯¥ç±»¾~–译之后åQŒè¢«ä¾èµ–的类改变了其¾cÕd®šä¹‰è€Œæ²¡æœ‰é‡æ–°ç¼–译所有的¾c»ï¼Œ˜q›è€Œå¼•å‘错误的情况ã€?br /> <br /> java.lang.NoClassDefFoundError<br /> <br /> 未找到类定义错误。当Java虚拟机或者类装蝲器试囑֮žä¾‹åŒ–某个¾c»ï¼Œè€Œæ‰¾ä¸åˆ°è¯¥ç±»çš„定义时抛出该错误ã€?br /> <br /> java.lang.NoSuchFieldError<br /> <br /> 域不存在错误。当应用试图讉K—®æˆ–者修æ”ÒŽŸ¾cȝš„某个域，而该¾cȝš„定义中没有该域的定义时抛å‡ø™¯¥é”™è¯¯ã€?br /> <br /> java.lang.NoSuchMethodError<br /> <br /> æ–ÒŽ³•ä¸å­˜åœ¨é”™è¯¯ã€‚当应用试图调用某类的某个方法，而该¾cȝš„定义中没有该æ–ÒŽ³•çš„定义时抛出该错误ã€?br /> <br /> java.lang.OutOfMemoryError<br /> <br /> 内存不èƒö错误。当可用内存不èƒö以让Java虚拟机分配给一个对象时抛出该错误ã€?br /> <br /> java.lang.StackOverflowError<br /> <br /> 堆栈溢出错误。当一个应用递归调用的层‹Æ¡å¤ªæ·Þp€Œå¯¼è‡´å †æ ˆæº¢å‡ºæ—¶æŠ›å‡ºè¯¥é”™è¯¯ã€?br /> <br /> java.lang.ThreadDeath<br /> <br /> ¾U¿ç¨‹¾l“束。当调用Thread¾cȝš„stopæ–ÒŽ³•æ—¶æŠ›å‡ø™¯¥é”™è¯¯åQŒç”¨äºŽæŒ‡½Cºçº¿½E‹ç»“束ã€?br /> <br /> java.lang.UnknownError<br /> <br /> 未知错误。用于指½CºJava虚拟机发生了未知严重错误的情å†üc€?br /> <br /> java.lang.UnsatisfiedLinkError<br /> <br /> 未满­‘³çš„链接错误。当Java虚拟机未扑ֈ°æŸä¸ª¾cȝš„声明为nativeæ–ÒŽ³•çš„本æœø™¯­­a€å®šä¹‰æ—¶æŠ›å‡ºã€?br /> <br /> java.lang.UnsupportedClassVersionError<br /> <br /> 不支持的¾cȝ‰ˆæœ¬é”™è¯¯ã€‚当Java虚拟æœø™¯•å›¾ä»Žè¯Õd–某个¾cÀL–‡ä»Óž¼Œä½†æ˜¯å‘现该文件的丅R€æ¬¡ç‰ˆæœ¬å·ä¸è¢«å½“前Java虚拟机支持的时候，抛出该错误ã€?br /> <br /> java.lang.VerifyError<br /> <br /> 验证错误。当验证器检‹¹‹åˆ°æŸä¸ª¾cÀL–‡ä»¶ä¸­å­˜åœ¨å†…部不兼å®ÒŽˆ–者安全问题时抛出该错误ã€?br /> <br /> java.lang.VirtualMachineError<br /> <br /> 虚拟机错误。用于指½Cø™™šæ‹Ÿæœºè¢«ç ´åæˆ–者ç‘ô¾l­æ‰§è¡Œæ“ä½œæ‰€éœ€çš„资源不­‘³çš„情况ã€?br /> <strong>4.6. æ³¨è§£½W¦å·¾cÕdž‹</strong><br /> <br /> java.lang.Deprecated<br /> <br /> 被废弃。用于指½Cºå‡ºäºŽå®‰å…¨æˆ–者有了更好的替代æ–ÒŽ¡ˆ½{‰åŽŸå› è€Œä¸é¼“励再ä‹É用的½E‹åºå…ƒç´ ã€‚当使用或者在未废弃的代码中覆盖被声明为Deprecated的程序元素时åQŒç¼–译器会发å‡ø™­¦å‘Šã€?br /> <br /> java.lang.Override<br /> <br /> 覆盖。用于指½CºæŸä¸ªç±»çš„方法被声明ä¸ø™¦æ±‚覆盖其父类的同一æ–ÒŽ³•çš„情å†üc€‚如果一个方法被声明覆盖¾cÕdž‹åQŒè€Œæ²¡æœ‰çœŸæ­£è¦†ç›–其父类的同一æ–ÒŽ³•åQŒé‚£ä¹ˆç¼–译器必须产生一个错误信息ã€?br /> <br /> java.lang.SuppressWarnings<br /> <br /> 消除警告。用于指½Cºåœ¨è¢«æ³¨è§£çš„½E‹åºå…ƒç´ ä¸­æ¶ˆé™¤æŸäº›ç‰¹å®šçš„命名警告。该注解大多用于深深地被嵌套的元素上ã€? <img src ="http://www.aygfsteel.com/alinglau36/aggbug/317100.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.aygfsteel.com/alinglau36/" target="_blank">lau</a> 2010-03-31 22:11 <a href="http://www.aygfsteel.com/alinglau36/archive/2010/03/31/317100.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>java enum 学习http://www.aygfsteel.com/alinglau36/archive/2009/12/21/306821.htmllaulauMon, 21 Dec 2009 08:41:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2009/12/21/306821.htmlhttp://www.aygfsteel.com/alinglau36/comments/306821.htmlhttp://www.aygfsteel.com/alinglau36/archive/2009/12/21/306821.html#Feedback0http://www.aygfsteel.com/alinglau36/comments/commentRss/306821.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/306821.html阅读全文

lau 2009-12-21 16:41 发表评论
]]>¾|‘络¾~–程之同步，é˜Õd¡žåQŒå¼‚步，非阻å¡?/title><link>http://www.aygfsteel.com/alinglau36/archive/2009/06/11/281399.html</link><dc:creator>lau</dc:creator><author>lau</author><pubDate>Thu, 11 Jun 2009 03:26:00 GMT</pubDate><guid>http://www.aygfsteel.com/alinglau36/archive/2009/06/11/281399.html</guid><wfw:comment>http://www.aygfsteel.com/alinglau36/comments/281399.html</wfw:comment><comments>http://www.aygfsteel.com/alinglau36/archive/2009/06/11/281399.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.aygfsteel.com/alinglau36/comments/commentRss/281399.html</wfw:commentRss><trackback:ping>http://www.aygfsteel.com/alinglau36/services/trackbacks/281399.html</trackback:ping><description><![CDATA[<p><font color="#ff0000">½{”案一åQ?br /> </font>1.异步传输 <br /> <br /> 通常åQŒå¼‚步传输是以字½W¦äؓ传输单位åQŒæ¯ä¸ªå­— ½W¦éƒ½è¦é™„åŠ?1 位è“v始位å’?1 位停止位åQŒä»¥æ ‡è®°ä¸€ä¸ªå­—½W¦çš„开始和¾l“束åQŒåƈ以此实现数据传输同步。所谓异步传输是指字½W¦ä¸Žå­—符(一个字½W¦ç»“束到下一个字½W¦å¼€å§?之间的时间间隔是可变的， òq¶ä¸éœ€è¦ä¸¥æ ¼åœ°é™åˆ¶å®ƒä»¬çš„时间关¾p…R€‚è“v始位对应于二˜q›åˆ¶å€?0åQŒä»¥ä½Žç”µòqŒ™¡¨½Cºï¼Œå ç”¨ 1 位宽度。停止位对应于二˜q›åˆ¶å€?1åQŒä»¥é«˜ç”µòqŒ™¡¨½Cºï¼Œå ç”¨ 1~2 位宽度。一个字½W¦å ç”?5~8位，具体取决于数据所采用的字½W¦é›†ã€‚例如，甉|Š¥ç å­—½W¦äØ“ 5 位、ASCII码字½W¦äØ“ 7 位、汉字码则äØ“8 位。此外，˜q˜è¦é™„加 1 位奇偶校验位åQŒå¯ä»¥é€‰æ‹©å¥‡æ ¡éªŒæˆ–偶校验方式对该字½W¦å®žæ–½ç®€å•çš„差错控制。发送端与接收端除了采用相同的数据格å¼?字符的位数、停止位的位数、有无校验位å? 校验方式½{?外，˜q˜åº”当采用相同的传输速率。典型的速率有：9 600 b/sã€?9.2kb/sã€?6kb/s½{‰ã€?<br /> <br /> 异步传输又称ä¸? èµäh­¢å¼å¼‚步通信方式åQŒå…¶ä¼˜ç‚¹æ˜¯ç®€å•ã€å¯é ï¼Œé€‚用于面向字½W¦çš„、低速的异步通信场合。例如，计算æœÞZ¸ŽModem之间的通信ž®±æ˜¯é‡‡ç”¨˜q™ç§æ–¹å¼ã€‚它的缺ç‚ÒŽ˜¯é€šä¿¡ 开销大，每传输一个字½W¦éƒ½è¦é¢å¤–附åŠ?ï½?位，通信效率比较低。例如，在ä‹É用Modem上网æ—Óž¼Œæ™®éæ„Ÿè§‰é€Ÿåº¦å¾ˆæ…¢åQŒé™¤äº†ä¼ è¾“速率低之外，与通信开销大、é€? 信效率低也密切相兟ë€?<br /> <br /> <br /> -------------------------------------------------------------------------------- <br /> <br /> 2. 同步传输 <br /> <br /> é€? 常，同步传输是以数据块äؓ传输单位。每个数据块的头部和ž®ùNƒ¨éƒ½è¦é™„加一个特ŒDŠçš„字符或比特序列，标记一个数据块的开始和¾l“束åQŒä¸€èˆ¬è¿˜è¦é™„加一个校验序åˆ? (å¦?6位或32位CRC校验ç ?åQŒä»¥ä¾¿å¯¹æ•°æ®å—进行差错控制。所谓同步传输是指数据块与数据块之间的时间间隔是固定的，必须严格地规定它们的旉™—´å…? ¾p…R€?nbsp;<br /> <br /> <font color="#ff0000">½{”案二：<br /> </font><font color="#000000">误‚®²è¯¦ç»†ä¸€äº›ï¼Œæœ¬äh比较弱智åQŒè°¢è°¢å„ä½? <br /> ---------------------------------------------------------------  <br />  <br /> 同步是阻塞模式，异步是非é˜Õd¡žæ¨¡å¼ã€? <br /> ---------------------------------------------------------------  <br />  <br /> 我的理解åQšåŒæ­¥æ˜¯æŒ‡ä¸¤ä¸ªçº¿½E‹çš„˜qè¡Œæ˜¯ç›¸å…³çš„åQŒå…¶ä¸­ä¸€ä¸ªçº¿½E‹è¦é˜Õd¡ž½{‰å¾…另外一个线½E‹çš„˜qè¡Œã€‚异步的意思是两个¾U¿ç¨‹æ¯«æ— ç›¸å…³åQŒè‡ªå·Þp¿è¡Œè‡ªå·Þqš„ã€? <br />  <br /> 不知寚w”™åQŸæ¥¼ä¸‹è¯´  <br /> ---------------------------------------------------------------  <br />  <br /> 同步是指åQšå‘送方发出数据后，½{‰æŽ¥æ”¶æ–¹å‘回响应以后才发下一个数据包的通讯方式ã€? <br /> 异步是指åQšå‘送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式ã€? <br />  <br /> CSDN上有讨论˜q?  <br /> http://expert.csdn.net/Expert/topic/2646/2646592.xml?temp=.3842584  <br /> http://expert.csdn.net/Expert/topic/2659/2659726.xml?temp=.1480219  <br /> ---------------------------------------------------------------  <br />  <br /> 举个不太恰当的例å­?ž®±åƒ:  <br /> SendMessage(...)  <br /> TRACE0("just  like  send");  <br />  <br /> PostMessage(...)  <br /> TRACE0("just  like  WSASend  using  overlapped");  <br />  <br /> SendMessage是调用的时候不˜q”回,½{‰æ¶ˆæ¯å“åº”后才执行TRACE0,˜q™å°±æ˜¯åŒæ­?  <br /> PostMessage是调用后马上˜q”回,不用消息响应ž®±æ‰§è¡ŒTRACE0,˜q™å°±æ˜¯å¼‚æ­?<br /> <br /> <font color="#ff0000">½{”案三：<br /> </font> </font></p> <div><font color="#000000"><a href="mhtml:%3E%3Cimg%20height=" return="" bbimg(this)?="" 13?="" src="mhtml:%20onmousewheel=" onload="javascript :if(this.width border='0' title='点击在新½H—口查看原始囄¡‰‡' onload='java_script_:if(this.width>500)this.width=500'>screen.width-500)this.style.width=screen.width-500;"> åŒæ­¥å’Œå¼‚步的区别</a> </font></div> <p><font color="#000000"> ä¸¾ä¸ªä¾‹å­åQšæ™®é€šB/S模式åQˆåŒæ­¥ï¼‰AJAX技术（异步åQ?br /> 同步åQšæäº¤è¯·æ±?>½{‰å¾…服务器处ç?>处理完毕˜q”回 ˜q™ä¸ªæœŸé—´å®¢æˆ·ç«¯æµè§ˆå™¨ä¸èƒ½òq²ä“Q何事<br /> 异步: è¯äh±‚通过事äšg触发->服务器处理（˜q™æ˜¯‹¹è§ˆå™¨ä»ç„¶å¯ä»¥ä½œå…¶ä»–事情åQ?>处理完毕<br /> --------------------------------------------------------------------------------------------------------------------<br /> 同步ž®±æ˜¯ä½ å«æˆ‘去吃饭åQŒæˆ‘听到了就和你åŽÕdƒé¥­ï¼›å¦‚果没有听到åQŒä½ ž®×ƒ¸åœçš„叫，直到我告诉你听到了，才一起去吃饭ã€?br /> 异步ž®±æ˜¯ä½ å«æˆ‘，然后自己åŽÕdƒé¥­ï¼Œæˆ‘得到消息后可能立即赎ͼŒä¹Ÿå¯èƒ½ç­‰åˆîC¸‹ç­æ‰åŽÕdƒé¥­ã€?/font></p> <p><font color="#000000">所以，要我请你吃饭ž®Þq”¨åŒæ­¥çš„方法，要请我吃饭就用异步的æ–ÒŽ³•åQŒè¿™æ ·ä½ å¯ä»¥çœé’±ã€?br /> --------------------------------------------------------------------------------------------------------------------<br /> 举个例子 打电话时同步 发消息是异步</font></p> <p><font color="#000000"><br /> </font></p> <p>同步åQšå‡½æ•°æ²¡æœ‰æ‰§è¡Œå®Œä¸è¿”回，¾U¿ç¨‹è¢«æŒ‚èµ?</p> <p>é˜Õd¡žåQšæ²¡æœ‰æ”¶å®Œæ•°æ®å‡½æ•îC¸˜q”回åQŒçº¿½E‹ä¹Ÿè¢«æŒ‚èµ?/p> <p>异步åQšå‡½æ•°ç«‹åŒ™¿”回，通过事äšg或是信号通知调用è€?/p> <p>非阻塞：函数立即˜q”回åQŒé€šè¿‡select通知调用è€?/p> <p>˜q™æ ·çœ‹æ¥å¼‚步和非é˜Õd¡žæœ‰ä»€ä¹ˆåŒºåˆ«å‘¢åQ?/p> <p>异步=非阻塞？</p> <p>同步是在操作¾pȝ»Ÿå±‚面上，é˜Õd¡žæ˜¯åœ¨å¥—接字上åQ?/p> <p>Reactor是同æ­?Proactor是异步？</p> <p><strong>回答åQ?/strong></p> <p>同步、异步、阻塞和非阻塞的概念</p> <p>　　在进行网¾lœç¼–½E‹æ—¶åQŒæˆ‘们常常见到同步、异步、阻塞和非阻塞四¿Uè°ƒç”¨æ–¹å¼ã€‚这些方式彼此概念åƈ不好理解。下面是我对˜q™äº›æœ¯è¯­çš„理解ã€?/p> <p><strong>同步</strong><br /> 所谓同步，ž®±æ˜¯åœ¨å‘å‡ÞZ¸€ä¸ªåŠŸèƒ½è°ƒç”¨æ—¶åQŒåœ¨æ²¡æœ‰å¾—到¾l“果之前åQŒè¯¥è°ƒç”¨ž®×ƒ¸˜q”回。按照这个定义，å…? 实绝大多数函数都是同步调用（例如sin, isdigit½{‰ï¼‰ã€‚但是一般而言åQŒæˆ‘们在说同步、异步的时候，ç‰ÒŽŒ‡é‚£äº›éœ€è¦å…¶ä»–部件协作或者需要一定时间完成的ä»ÕdŠ¡ã€‚最常见的例子就æ˜? SendMessage。该函数发送一个消息给某个½H—口åQŒåœ¨å¯ÒŽ–¹å¤„理完消息之前，˜q™ä¸ªå‡½æ•°ä¸è¿”回。当å¯ÒŽ–¹å¤„理完毕以后åQŒè¯¥å‡½æ•°æ‰æŠŠæ¶ˆæ¯å¤„理函数所˜q”回çš? LRESULTå€ÆD¿”回给调用者ã€?/p> <p><strong>异步</strong><br /> 异步的概念和同步相对。当一个异步过½E‹è°ƒç”¨å‘出后åQŒè°ƒç”¨è€…不能立åˆÕd¾—到结果。实际处理这个调ç”? 的部件在完成后，通过状态、通知和回调来通知调用者。以 CAsycSocket¾cÖMؓ例（注意åQŒCSocket从CAsyncSocket‹z„¡”ŸåQŒä½†æ˜¯è“v功能已经由异步è{化äؓ同步åQ‰ï¼Œå½“一个客æˆïL«¯é€šè¿‡è°ƒç”¨ Connect函数发出一个连接请求后åQŒè°ƒç”¨è€…线½E‹ç«‹åˆÕd¯ä»¥æœä¸‹è¿è¡Œã€‚当˜qžæŽ¥çœŸæ­£å»ºç«‹èµäh¥ä»¥åŽåQŒsocket底层会发送一个消息通知该对象。这里提到执è¡? 部äšg和调用者通过三种途径˜q”回¾l“æžœåQšçŠ¶æ€ã€é€šçŸ¥å’Œå›žè°ƒã€‚可以ä‹É用哪一¿Uä¾èµ–于执行部äšg的实玎ͼŒé™¤éžæ‰§è¡Œéƒ¨äšg提供多种选择åQŒå¦åˆ™ä¸å—调用者控制。如果执行部 件用状态来通知åQŒé‚£ä¹ˆè°ƒç”¨è€…就需要每隔一定时间检查一‹Æ¡ï¼Œæ•ˆçŽ‡ž®±å¾ˆä½Žï¼ˆæœ‰äº›åˆå­¦å¤šçº¿½E‹ç¼–½E‹çš„人，æ€Õd–œ‹Æ¢ç”¨ä¸€ä¸ªåó@环去‹‚€æŸ¥æŸä¸ªå˜é‡çš„å€û|¼Œ˜q™å…¶å®žæ˜¯ä¸€¿Uå¾ˆä¸¥é‡ 的错误）。如果是使用通知的方式，效率则很高，因äؓ执行部äšg几乎不需要做额外的操作。至于回调函敎ͼŒå…¶å®žå’Œé€šçŸ¥æ²¡å¤ªå¤šåŒºåˆ«ã€?/p> <p><strong>é˜Õd¡ž</strong><br /> é˜Õd¡žè°ƒç”¨æ˜¯æŒ‡è°ƒç”¨¾l“æžœ˜q”回之前åQŒå½“前线½E‹ä¼šè¢«æŒ‚èµ—÷€‚函数只有在得到¾l“果之后才会˜q”回。有äºÞZ¹Ÿè®? 会把é˜Õd¡žè°ƒç”¨å’ŒåŒæ­¥è°ƒç”¨ç­‰åŒè“v来，实际上他是不同的。对于同 步调用来è¯ß_¼Œå¾ˆå¤šæ—¶å€™å½“前线½E‹è¿˜æ˜¯æ¿€‹zȝš„åQŒåªæ˜¯ä»Žé€»è¾‘上当前函数没有返回而已。例如，我们在CSocket中调用Receive函数åQŒå¦‚果缓冲区中没有数 据，˜q™ä¸ªå‡½æ•°ž®×ƒ¼šä¸€ç›´ç­‰å¾…，直到有数据才˜q”回。而此æ—Óž¼Œå½“前¾U¿ç¨‹˜q˜ä¼š¾l§ç®‹å¤„理各种各样的消息。如果主½H—口和调用函数在同一个线½E‹ä¸­åQŒé™¤éžä½ åœ¨ç‰¹ŒDŠçš„界面æ“? 作函æ•îC¸­è°ƒç”¨åQŒå…¶å®žä¸»ç•Œé¢˜q˜æ˜¯åº”该可以åˆäh–°ã€‚socket接收数据的另外一个函数recv则是一个阻塞调用的例子。当socket工作在阻塞模式的时候， 如果没有数据的情况下调用该函敎ͼŒåˆ™å½“前线½E‹å°±ä¼šè¢«æŒ‚è“våQŒç›´åˆ°æœ‰æ•°æ®ä¸ºæ­¢ã€?/p> <p><strong>非阻å¡?/strong><br /> 非阻塞和é˜Õd¡žçš„概å¿ëŠ›¸å¯¹åº”åQŒæŒ‡åœ¨ä¸èƒ½ç«‹åˆÕd¾—到结果之前，该函æ•îC¸ä¼šé˜»å¡žå½“前线½E‹ï¼Œè€Œä¼šç«‹åˆ»˜q”回ã€?/p> <p>　　对象的阻塞模式和é˜Õd¡žå‡½æ•°è°ƒç”¨<br /> 对象是否处于é˜Õd¡žæ¨¡å¼å’Œå‡½æ•°æ˜¯ä¸æ˜¯é˜Õd¡žè°ƒç”¨æœ‰å¾ˆå¼ºçš„相关性，但是òq¶ä¸æ˜¯ä¸€ä¸€å¯¹åº”的。阻塞对象上可以æœ? 非阻塞的调用方式åQŒæˆ‘们可以通过一定的API去轮询状 态，在适当的时候调用阻塞函敎ͼŒž®±å¯ä»¥é¿å…é˜»å¡žã€‚而对于非é˜Õd¡žå¯¹è±¡åQŒè°ƒç”¨ç‰¹ŒDŠçš„函数也可以进入阻塞调用。函数selectž®±æ˜¯˜q™æ ·çš„一个例子ã€?/p> <img src ="http://www.aygfsteel.com/alinglau36/aggbug/281399.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.aygfsteel.com/alinglau36/" target="_blank">lau</a> 2009-06-11 11:26 <a href="http://www.aygfsteel.com/alinglau36/archive/2009/06/11/281399.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>StringUtils工具¾cȝš„常用æ–ÒŽ³•http://www.aygfsteel.com/alinglau36/archive/2009/04/10/264885.htmllaulauFri, 10 Apr 2009 09:03:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2009/04/10/264885.htmlhttp://www.aygfsteel.com/alinglau36/comments/264885.htmlhttp://www.aygfsteel.com/alinglau36/archive/2009/04/10/264885.html#Feedback0http://www.aygfsteel.com/alinglau36/comments/commentRss/264885.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/264885.html

StringUtils工具¾cȝš„常用æ–ÒŽ³•

关键� stringutils

StringUtils æ–ÒŽ³•çš„操作对象是 java.lang.String ¾cÕdž‹çš„对象，æ˜?JDK 提供çš?String ¾cÕdž‹æ“ä½œæ–ÒŽ³•çš„补充，òq¶ä¸”æ˜?null 安全çš?卛_¦‚果输入参æ•?String ä¸?null 则不会抛å‡?nbsp; NullPointerException åQŒè€Œæ˜¯åšäº†ç›¸åº”处理åQŒä¾‹å¦‚，如果输入ä¸?null 则返回也æ˜? null ½{‰ï¼Œå…·ä½“可以查看源代ç ?ã€?br />
除了构造器åQ?span style="font-family: verdana,geneva;">StringUtils 中一共有130多个æ–ÒŽ³•åQŒåƈ且都æ˜?static 的，所以我们可以这栯‚°ƒç”?StringUtils.xxx()

下面分别对一些常用方法做½Ž€è¦ä»‹¾lï¼š

1. public static boolean isEmpty(String str)
   判断某字½W¦ä¸²æ˜¯å¦ä¸ºç©ºåQŒäØ“½Iºçš„标准æ˜?str==null æˆ?str.length()==0
   下面æ˜?StringUtils 判断是否为空的示例：

StringUtils.isEmpty(null) = true
StringUtils.isEmpty("") = true
StringUtils.isEmpty(" ") = false //注意åœ?StringUtils 中空æ ég½œéžç©ºå¤„理
StringUtils.isEmpty("   ") = false
StringUtils.isEmpty("bob") = false
StringUtils.isEmpty(" bob ") = false

2. public static boolean isNotEmpty(String str)
   判断某字½W¦ä¸²æ˜¯å¦éžç©ºåQŒç­‰äº?!isEmpty(String str)
   下面是示例：

      StringUtils.isNotEmpty(null) = false
      StringUtils.isNotEmpty("") = false
      StringUtils.isNotEmpty(" ") = true
      StringUtils.isNotEmpty("         ") = true
      StringUtils.isNotEmpty("bob") = true
      StringUtils.isNotEmpty(" bob ") = true

3. public static boolean isBlank(String str)
   判断某字½W¦ä¸²æ˜¯å¦ä¸ºç©ºæˆ–长度äØ“0或由½Iºç™½½W?span style="font-family: verdana,geneva;">(whitespace) 构成
   下面是示例：
      StringUtils.isBlank(null) = true
      StringUtils.isBlank("") = true
      StringUtils.isBlank(" ") = true
      StringUtils.isBlank("        ") = true
      StringUtils.isBlank(""t "n "f "r") = true   //对于制表½W¦ã€æ¢è¡Œç¬¦ã€æ¢™å늬¦å’Œå›žè½¦ç¬¦

      StringUtils.isBlank()   //均识为空白符
      StringUtils.isBlank(""b") = false   //""b"为单词边界符
      StringUtils.isBlank("bob") = false
      StringUtils.isBlank(" bob ") = false

4. public static boolean isNotBlank(String str)
   判断某字½W¦ä¸²æ˜¯å¦ä¸äØ“½IÞZ¸”长度不äØ“0且不ç”Þq©ºç™½ç¬¦(whitespace) 构成åQŒç­‰äº?!isBlank(String str)
   下面是示例：

      StringUtils.isNotBlank(null) = false
      StringUtils.isNotBlank("") = false
      StringUtils.isNotBlank(" ") = false
      StringUtils.isNotBlank("         ") = false
      StringUtils.isNotBlank(""t "n "f "r") = false
      StringUtils.isNotBlank(""b") = true
      StringUtils.isNotBlank("bob") = true
      StringUtils.isNotBlank(" bob ") = true

5. public static String trim(String str)
   åŽÀLŽ‰å­—符串两端的控制½W?span style="font-family: verdana,geneva;">(control characters, char <= 32) , 如果输入ä¸?null 则返å›?span style="font-family: verdana,geneva;">null
   下面是示例：
      StringUtils.trim(null) = null
      StringUtils.trim("") = ""
      StringUtils.trim(" ") = ""
      StringUtils.trim("  "b "t "n "f "r    ") = ""
      StringUtils.trim("     "n"tss   "b") = "ss"
      StringUtils.trim(" d   d dd     ") = "d   d dd"
      StringUtils.trim("dd     ") = "dd"
      StringUtils.trim("     dd       ") = "dd"

6. public static String trimToNull(String str)
   åŽÀLŽ‰å­—符串两端的控制½W?span style="font-family: verdana,geneva;">(control characters, char <= 32) ,如果变äØ“ null æˆ?"åQŒåˆ™˜q”回 null
   下面是示例：
      StringUtils.trimToNull(null) = null
      StringUtils.trimToNull("") = null
      StringUtils.trimToNull(" ") = null
      StringUtils.trimToNull("     "b "t "n "f "r    ") = null
      StringUtils.trimToNull("     "n"tss   "b") = "ss"
      StringUtils.trimToNull(" d   d dd     ") = "d   d dd"
      StringUtils.trimToNull("dd     ") = "dd"
      StringUtils.trimToNull("     dd       ") = "dd"

7. public static String trimToEmpty(String str)
   åŽÀLŽ‰å­—符串两端的控制½W?span style="font-family: verdana,geneva;">(control characters, char <= 32) ,如果变äØ“ null æˆ?"" åQŒåˆ™˜q”回 ""
   下面是示例：
      StringUtils.trimToEmpty(null) = ""
      StringUtils.trimToEmpty("") = ""
      StringUtils.trimToEmpty(" ") = ""
      StringUtils.trimToEmpty("     "b "t "n "f "r    ") = ""
      StringUtils.trimToEmpty("     "n"tss   "b") = "ss"
      StringUtils.trimToEmpty(" d   d dd     ") = "d   d dd"
      StringUtils.trimToEmpty("dd     ") = "dd"
      StringUtils.trimToEmpty("     dd       ") = "dd"

8. public static String strip(String str)
   åŽÀLŽ‰å­—符串两端的½Iºç™½½W?span style="color: #0000ff; font-family: verdana,geneva;">(whitespace) åQŒå¦‚果输入äØ“ null 则返å›?null
   下面是示ä¾?注意å’?span style="color: #0000ff; font-family: verdana,geneva;"> trim() 的区åˆ?åQ?br />       StringUtils.strip(null) = null
      StringUtils.strip("") = ""
      StringUtils.strip(" ") = ""
      StringUtils.strip("     "b "t "n "f "r    ") = ""b"
      StringUtils.strip("     "n"tss   "b") = "ss   "b"
      StringUtils.strip(" d   d dd     ") = "d   d dd"
      StringUtils.strip("dd     ") = "dd"
      StringUtils.strip("     dd       ") = "dd"

9. public static String stripToNull(String str)
   åŽÀLŽ‰å­—符串两端的½Iºç™½½W?span style="color: #0000ff; font-family: verdana,geneva;">(whitespace) åQŒå¦‚果变ä¸? null æˆ?"åQŒåˆ™˜q”回 null
   下面是示ä¾?注意å’?trimToNull() 的区åˆ?åQ?br />       StringUtils.stripToNull(null) = null
      StringUtils.stripToNull("") = null
      StringUtils.stripToNull(" ") = null
      StringUtils.stripToNull("     "b "t "n "f "r    ") = ""b"
      StringUtils.stripToNull("     "n"tss   "b") = "ss   "b"
      StringUtils.stripToNull(" d   d dd     ") = "d   d dd"
      StringUtils.stripToNull("dd     ") = "dd"
      StringUtils.stripToNull("     dd       ") = "dd"

10. public static String stripToEmpty(String str)
    åŽÀLŽ‰å­—符串两端的½Iºç™½½W?span style="color: #0000ff; font-family: verdana,geneva;">(whitespace) åQŒå¦‚果变ä¸?span style="font-family: verdana,geneva;"> null æˆ?span style="font-family: verdana,geneva;">"" åQŒåˆ™˜q”回""
    下面是示ä¾?注意å’?trimToEmpty() 的区åˆ?åQ?br />       StringUtils.stripToNull(null) = ""
      StringUtils.stripToNull("") = ""
      StringUtils.stripToNull(" ") = ""
      StringUtils.stripToNull("     "b "t "n "f "r    ") = ""b"
      StringUtils.stripToNull("     "n"tss   "b") = "ss   "b"
      StringUtils.stripToNull(" d   d dd     ") = "d   d dd"
      StringUtils.stripToNull("dd     ") = "dd"
      StringUtils.stripToNull("     dd       ") = "dd"

以下æ–ÒŽ³•åªä»‹¾lå…¶åŠŸèƒ½åQŒä¸å†ä‹D例：
11. public static String strip(String str, String stripChars)
   åŽÀLŽ‰ str 两端的在 stripChars 中的字符ã€?br />    如果 str ä¸?null 或等äº?span style="font-family: verdana,geneva;">"" åQŒåˆ™˜q”回它本íw«ï¼›
   如果 stripChars ä¸?null æˆ?span style="font-family: verdana,geneva;">"" åQŒåˆ™˜q”回 strip(String str) ã€?br />
12. public static String stripStart(String str, String stripChars)
    å’?1ç›æ€¼¼åQŒåŽ»æŽ?span style="font-family: verdana,geneva;"> str 前端的在 stripChars 中的字符ã€?br />
13. public static String stripEnd(String str, String stripChars)
    å’?1ç›æ€¼¼åQŒåŽ»æŽ?str 末端的在 stripChars 中的字符ã€?br />
14. public static String[] stripAll(String[] strs)
    对字½W¦ä¸²æ•°ç»„中的每个字符串进è¡? strip(String str) åQŒç„¶åŽè¿”回ã€?br />     如果 strs ä¸?null æˆ?strs 长度ä¸?åQŒåˆ™˜q”回 strs 本èín

15. public static String[] stripAll(String[] strs, String stripChars)
    对字½W¦ä¸²æ•°ç»„中的每个字符串进è¡?strip(String str, String stripChars) åQŒç„¶åŽè¿”回ã€?br />     如果 strs ä¸?null æˆ?strs 长度ä¸?åQŒåˆ™˜q”回 strs 本èín

16. public static boolean equals(String str1, String str2)
    比较两个字符串是否相½{‰ï¼Œå¦‚果两个均äØ“½Iºåˆ™ä¹Ÿè®¤ä¸ºç›¸½{‰ã€?br />
17. public static boolean equalsIgnoreCase(String str1, String str2)
    比较两个字符串是否相½{‰ï¼Œä¸åŒºåˆ†å¤§ž®å†™åQŒå¦‚果两个均为空则也认äؓ相等ã€?br />
18. public static int indexOf(String str, char searchChar)
    ˜q”回字符 searchChar 在字½W¦ä¸² str 中第一‹Æ¡å‡ºçŽ°çš„位置ã€?br />     如果 searchChar 没有åœ?str 中出现则˜q”回-1åQ?br />     如果 str ä¸?null æˆ?"" åQŒåˆ™ä¹Ÿè¿”å›?1

19. public static int indexOf(String str, char searchChar, int startPos)
    ˜q”回字符 searchChar ä»?startPos 开始在字符ä¸?str 中第一‹Æ¡å‡ºçŽ°çš„位置ã€?br />     如果ä»?startPos å¼€å§?searchChar 没有åœ?span style="font-family: verdana,geneva;"> str 中出现则˜q”回-1åQ?br />     如果 str ä¸?null æˆ?"" åQŒåˆ™ä¹Ÿè¿”å›?1

20. public static int indexOf(String str, String searchStr)
    ˜q”回字符ä¸? searchStr 在字½W¦ä¸² str 中第一‹Æ¡å‡ºçŽ°çš„位置ã€?br />     如果 str ä¸?null æˆ?searchStr ä¸?null 则返å›?1åQ?br />     如果 searchStr ä¸?"" ,ä¸?span style="font-family: verdana,geneva;"> str ä¸ÞZ¸ä¸?null åQŒåˆ™˜q”回0åQ?br />     如果 searchStr 不在 str 中，则返å›?1

21. public static int ordinalIndexOf(String str, String searchStr, int ordinal)
    ˜q”回字符ä¸?searchStr 在字½W¦ä¸² str 中第 ordinal ‹Æ¡å‡ºçŽ°çš„位置ã€?br />     如果 str=null æˆ?searchStr=null æˆ?ordinal<=0 则返å›?1
    举例(*代表ä»ÀL„å­—符ä¸?åQ?br />       StringUtils.ordinalIndexOf(null, *, *) = -1
      StringUtils.ordinalIndexOf(*, null, *) = -1
      StringUtils.ordinalIndexOf("", "", *) = 0
      StringUtils.ordinalIndexOf("aabaabaa", "a", 1) = 0
      StringUtils.ordinalIndexOf("aabaabaa", "a", 2) = 1
      StringUtils.ordinalIndexOf("aabaabaa", "b", 1) = 2
      StringUtils.ordinalIndexOf("aabaabaa", "b", 2) = 5
      StringUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1
      StringUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4
      StringUtils.ordinalIndexOf("aabaabaa", "bc", 1) = -1
      StringUtils.ordinalIndexOf("aabaabaa", "", 1) = 0
      StringUtils.ordinalIndexOf("aabaabaa", "", 2) = 0

22. public static int indexOf(String str, String searchStr, int startPos)
    ˜q”回字符ä¸?searchStr ä»?startPos 开始在字符ä¸?str 中第一‹Æ¡å‡ºçŽ°çš„位置ã€?br />     举例(*代表ä»ÀL„å­—符ä¸?åQ?br />       StringUtils.indexOf(null, *, *) = -1
      StringUtils.indexOf(*, null, *) = -1
      StringUtils.indexOf("", "", 0) = 0
      StringUtils.indexOf("aabaabaa", "a", 0) = 0
      StringUtils.indexOf("aabaabaa", "b", 0) = 2
      StringUtils.indexOf("aabaabaa", "ab", 0) = 1
      StringUtils.indexOf("aabaabaa", "b", 3) = 5
      StringUtils.indexOf("aabaabaa", "b", 9) = -1
      StringUtils.indexOf("aabaabaa", "b", -1) = 2
      StringUtils.indexOf("aabaabaa", "", 2) = 2
      StringUtils.indexOf("abc", "", 9) = 3

23. public static int lastIndexOf(String str, char searchChar)
    基本原理å?8

24. public static int lastIndexOf(String str, char searchChar, int startPos)
    基本原理å?9

25. public static int lastIndexOf(String str, String searchStr)
    基本原理å?0

26. public static int lastIndexOf(String str, String searchStr, int startPos)
    基本原理å?2

另附åQ?br />
String çš?split(String regex)   æ–ÒŽ³•çš„用æ³?br /> 如果我们需要把某个字符串拆分äؓ字符串数¾l„，则通常ç”?span style="font-family: verdana,geneva;"> split(String regex) 来实现ã€?br />
例如åQ?br />

Java代码 复制代码
  1. String str = "aa,bb,cc,dd";      
  2. String[] strArray = str.split(",");       
  3. System.out.println(strArray.length);      
  4.   for (int i = 0; i < strArray.length; i++) {      
  5.        System.out.println(strArray[i]);      
  6. }  
String str = "aa,bb,cc,dd";
String[] strArray = str.split(",");
System.out.println(strArray.length);
for (int i = 0; i < strArray.length; i++) {
System.out.println(strArray[i]);
}
 

¾l“果为：
4
aa
bb
cc
dd

如果åQ?br /> String str = "aa.bb.cc.dd";
String[] strArray = str.split(".");

则结果äØ“åQ?

ä¸ÞZ»€ä¹ˆç»“果不是我们所想的呢，原因是参æ•?span style="font-family: verdana,geneva;"> String regex 是正则表辑ּ (regular expression) 而不是普通字½W¦ä¸²åQŒè€?"." 在正则表辑ּä¸­æœ‰ç‰ÒŽ®Šå«ä¹‰åQŒè¡¨½CºåŒ¹é…æ‰€æœ‰å•ä¸ªå­—½W¦ã€‚如果要那样拆分åQŒæˆ‘们必™åȝ»™ "." ˜q›è¡Œè½¬ä¹‰åQ?span style="font-family: verdana,geneva;">String[] strArray = str.split(".") 修改ä¸?String[] strArray = str.split(""".") 卛_¯ã€?br /> 另外有关 StringUtils 的详¾l?API 请参见官方网ç«?span style="font-family: arial,helvetica,sans-serif;">: http://commons.apache.org/lang/api/org/apache/commons/lang/StringUtils.html



lau 2009-04-10 17:03 发表评论
]]>java¾lå…¸åŸºç¡€http://www.aygfsteel.com/alinglau36/archive/2009/03/30/262887.htmllaulauMon, 30 Mar 2009 06:55:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2009/03/30/262887.htmlhttp://www.aygfsteel.com/alinglau36/comments/262887.htmlhttp://www.aygfsteel.com/alinglau36/archive/2009/03/30/262887.html#Feedback0http://www.aygfsteel.com/alinglau36/comments/commentRss/262887.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/262887.html对于˜q™ä¸ª¾pÕdˆ—里的问题åQŒæ¯ä¸ªå­¦Javaçš„äh都应该搞懂。当ç„Óž¼Œå¦‚果只是学Java玩玩ž®±æ— æ‰€è°“了。如果你认äؓ自己已经­‘…越初学者了åQŒå´ä¸å¾ˆæ‡‚这些问题，请将你自己重归初学者行列。内容均来自于CSDN的经典老脓ã€?/font>

        问题一åQšæˆ‘声明了什么！

       String s = "Hello world!";

       许多人都做过˜q™æ ·çš„事情，但是åQŒæˆ‘们到底声明了什么？回答通常是：一个StringåQŒå†…å®ÒŽ˜¯“Hello world!”。这æ äh¨¡¾pŠçš„回答通常是概念不清的æ ÒŽºã€‚如果要准确的回½{”，一半的人大概会回答错误ã€?br /> ˜q™ä¸ªè¯­å¥å£°æ˜Žçš„是一个指向对象的引用åQŒåä¸?#8220;s”åQŒå¯ä»¥æŒ‡å‘类型äØ“Stringçš„ä“Q何对象，目前指向"Hello world!"˜q™ä¸ªString¾cÕdž‹çš„对è±?/strong>ã€?/font>˜q™å°±æ˜¯çœŸæ­£å‘生的事情。我们åƈ没有声明一个String对象åQŒæˆ‘们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：

      String string = s;

      我们是声明了另外一个只能指向String对象的引用，名äØ“stringåQŒåƈ没有½W¬äºŒä¸ªå¯¹è±¡äñ”生，string˜q˜æ˜¯æŒ‡å‘原来那个对象åQŒä¹Ÿž®±æ˜¯åQŒå’Œs指向同一个对象ã€?br />
      问题二："=="å’Œequalsæ–ÒŽ³•½I¶ç«Ÿæœ‰ä»€ä¹ˆåŒºåˆ«ï¼Ÿ

      ==操作½W¦ä¸“门用来比较变量的值是否相½{‰ã€‚比较好理解的一ç‚ÒŽ˜¯åQ?br />       int a=10;
      int b=10;
      则a==bž®†æ˜¯trueã€?br />       但不好理解的地方是：
      String a=new String("foo");
      String b=new String("foo");
      则a==bž®†è¿”回falseã€?br />
      æ ÒŽ®å‰ä¸€å¸–说˜q‡ï¼Œå¯¹è±¡å˜é‡å…¶å®žæ˜¯ä¸€ä¸ªå¼•ç”¨ï¼Œå®ƒä»¬çš„值是指向对象所在的内存地址åQŒè€Œä¸æ˜¯å¯¹è±¡æœ¬íw«ã€‚aå’Œb都ä‹É用了new操作½W¦ï¼Œæ„å‘³ç€ž®†åœ¨å†…存中äñ”生两个内容äØ“"foo"çš„å­—½W¦ä¸²åQŒæ—¢ç„¶æ˜¯“两个”åQŒå®ƒä»¬è‡ªç„¶ä½äºŽä¸åŒçš„内存地址。aå’Œb的值其实是两个不同的内存地址的å€û|¼Œæ‰€ä»¥ä‹Éç”?=="操作½W¦ï¼Œ¾l“果会是false。诚ç„Óž¼Œaå’Œb所指的对象åQŒå®ƒä»¬çš„内容都是"foo"åQŒåº”该是“相等”åQ?font color="#ff0000">但是==操作½W¦åƈ不涉及到对象内容的比较ã€?/strong>对象内容的比较，正是equalsæ–ÒŽ³•åšçš„事ã€?/strong>

      看一下Object对象的equalsæ–ÒŽ³•æ˜¯å¦‚何实现的åQ?br />       boolean equals(Object o){

      return this==o;

      }
      Object对象默认使用äº?=操作½W¦ã€‚所以如果你自创的类没有覆盖equalsæ–ÒŽ³•åQŒé‚£ä½ çš„¾cÖM‹É用equalså’Œä‹Éç”?=会得到同æ ïLš„¾l“果。同样也可以看出åQŒObjectçš„equalsæ–ÒŽ³•æ²¡æœ‰è¾‘Öˆ°equalsæ–ÒŽ³•åº”该辑ֈ°çš„目标：比较两个对象内容是否相等。因为答案应该由¾cȝš„创徏者决定，所以Object把这个ä“Q务留¾l™äº†¾cȝš„创徏者ã€?br />
      看一下一个极端的¾c»ï¼š
      Class Monster{
      private String content;
      ...
      boolean equals(Object another){ return true;}

      }
      我覆盖了equalsæ–ÒŽ³•ã€‚这个实çŽîC¼šå¯ÆD‡´æ— è®ºMonster实例内容如何åQŒå®ƒä»¬ä¹‹é—´çš„比较永远˜q”回trueã€?br />
所以当你是用equalsæ–ÒŽ³•åˆ¤æ–­å¯¹è±¡çš„内å®ÒŽ˜¯å¦ç›¸½{‰ï¼Œè¯·ä¸è¦æƒ³å½“然。因为可能你认äؓ相等åQŒè€Œè¿™ä¸ªç±»çš„作者不˜q™æ ·è®¤äØ“åQŒè€Œç±»çš„equalsæ–ÒŽ³•çš„实现是ç”׃»–掌握的。如果你需要ä‹É用equalsæ–ÒŽ³•åQŒæˆ–者ä‹É用ä“Q何基于散列码的集合（HashSet,HashMap,HashTableåQ‰ï¼Œè¯·å¯Ÿçœ‹ä¸€ä¸‹java doc以确认这个类的equals逻辑是如何实现的ã€?br />
      问题三：String到底变了没有åQ?/strong>

      没有。因为String被设计成不可å?immutable)¾c»ï¼Œæ‰€ä»¥å®ƒçš„所有对象都是不可变对象。请看下列代码：

      String s = "Hello";
      s = s + " world!";

      s所指向的对象是否改变了呢？从本¾pÕdˆ—½W¬ä¸€½‹‡çš„¾l“论很容易导å‡ø™¿™ä¸ªç»“论。我们来看看发生了什么事情。在˜q™æ®µä»£ç ä¸­ï¼Œs原先指向一个String对象åQŒå†…å®ÒŽ˜¯"Hello"åQŒç„¶åŽæˆ‘们对s˜q›è¡Œäº?操作åQŒé‚£ä¹ˆs所指向的那个对象是否发生了改变呢？½{”案是没有。这æ—Óž¼Œs不指向原来那个对象了åQŒè€ŒæŒ‡å‘了另一个String对象åQŒå†…容äØ“"Hello world!"åQŒåŽŸæ¥é‚£ä¸ªå¯¹è±¡è¿˜å­˜åœ¨äºŽå†…存之中，只是s˜q™ä¸ªå¼•ç”¨å˜é‡ä¸å†æŒ‡å‘它了ã€?br /> 通过上面的说明，我们很容易导出另一个结论，如果¾lå¸¸å¯¹å­—½W¦ä¸²˜q›è¡Œå„种各样的修改，或者说åQŒä¸å¯é¢„见的修改åQŒé‚£ä¹ˆä‹É用String来代表字½W¦ä¸²çš„话会引起很大的内存开销。因为String对象建立之后不能再改变，所以对于每一个不同的字符ä¸ÔŒ¼Œéƒ½éœ€è¦ä¸€ä¸ªString对象来表½Cºã€‚è¿™æ—Óž¼Œåº”该考虑使用StringBuffer¾c»ï¼Œå®ƒå…è®æ€¿®æ”¹ï¼Œè€Œä¸æ˜¯æ¯ä¸ªä¸åŒçš„字符串都要生成一个新的对象。åƈ且，˜q™ä¸¤¿Uç±»çš„对象è{换十分容易ã€?br /> 同时åQŒæˆ‘们还可以知道åQŒå¦‚果要使用内容相同的字½W¦ä¸²åQŒä¸å¿…每‹Æ¡éƒ½new一个String。例如我们要在构造器中对一个名叫sçš„String引用变量˜q›è¡Œåˆå§‹åŒ–，把它讄¡½®ä¸ºåˆå§‹å€û|¼Œåº”当˜q™æ ·åšï¼š
      public class Demo {
         private String s;
         ...
         public Demo {
           s = "Initial Value";
         }
         ...
      }
      而非 s = new String("Initial Value");
      后者每‹Æ¡éƒ½ä¼šè°ƒç”¨æž„造器åQŒç”Ÿæˆæ–°å¯¹è±¡åQŒæ€§èƒ½ä½Žä¸‹ä¸”内存开销大，òq¶ä¸”没有意义åQŒå› ä¸ºString对象不可改变åQŒæ‰€ä»¥å¯¹äºŽå†…容相同的字符ä¸ÔŒ¼Œåªè¦ä¸€ä¸ªString对象来表½Cºå°±å¯ä»¥äº†ã€‚也ž®Þp¯´åQŒå¤š‹Æ¡è°ƒç”¨ä¸Šé¢çš„构造器创徏多个对象åQŒä»–们的String¾cÕdž‹å±žæ€§s都指向同一个对象ã€?br /> 上面的结è®ø™¿˜åŸÞZºŽ˜q™æ ·ä¸€ä¸ªäº‹å®žï¼šå¯¹äºŽå­—符串常量，如果内容相同åQŒJava认äؓ它们代表同一个String对象。而用关键字new调用构造器åQŒæ€ÀL˜¯ä¼šåˆ›å»ÞZ¸€ä¸ªæ–°çš„对象，无论内容是否相同ã€?br /> 至于ä¸ÞZ»€ä¹ˆè¦æŠŠString¾c»è®¾è®¡æˆä¸å¯å˜ç±»åQŒæ˜¯å®ƒçš„用途决定的。其实不只StringåQŒå¾ˆå¤šJava标准¾cÕdº“中的¾c»éƒ½æ˜¯ä¸å¯å˜çš„。在开发一个系¾lŸçš„时候，我们有时候也需要设计不可变¾c»ï¼Œæ¥ä¼ é€’一¾l„相关的å€û|¼Œ˜q™ä¹Ÿæ˜¯é¢å‘对象思想的体现。不可变¾cÀLœ‰ä¸€äº›ä¼˜ç‚¹ï¼Œæ¯”如因äؓ它的对象是只è¯Èš„åQŒæ‰€ä»¥å¤š¾U¿ç¨‹òq¶å‘讉K—®ä¹Ÿä¸ä¼šæœ‰ä»ÖM½•é—®é¢˜ã€‚当然也有一些缺点，比如每个不同的状态都要一个对象来代表åQŒå¯èƒ½ä¼šé€ æˆæ€§èƒ½ä¸Šçš„问题。所以Java标准¾cÕdº“˜q˜æä¾›äº†ä¸€ä¸ªå¯å˜ç‰ˆæœ¬ï¼Œå³StringBufferã€?br />
      问题四：final关键字到底修é¥îCº†ä»€ä¹ˆï¼Ÿ

      final使得被修饰的变量"不变"åQŒä½†æ˜¯ç”±äºŽå¯¹è±¡åž‹å˜é‡çš„本质是“引用”åQŒä‹Éå¾?#8220;不变”也有了两¿Uå«ä¹‰ï¼šå¼•ç”¨æœ¬èín的不变，和引用指向的对象不变ã€?br />
      引用本èín的不变：
      final StringBuffer a=new StringBuffer("immutable");
      final StringBuffer b=new StringBuffer("not immutable");
      a=b;//¾~–译期错è¯?br />
      引用指向的对象不变：
      final StringBuffer a=new StringBuffer("immutable");
      a.append(" broken!"); //¾~–译通过

      可见åQ?font color="#ff0000">final只对引用çš?#8220;å€?#8221;(也即它所指向的那个对象的内存地址)有效åQŒå®ƒ˜q«ä‹É引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化åQŒfinal是不负责的。这很类ä¼?=操作½W¦ï¼š==操作½W¦åªè´Ÿè´£å¼•ç”¨çš?#8220;å€?#8221;相等åQŒè‡³äºŽè¿™ä¸ªåœ°å€æ‰€æŒ‡å‘的对象内å®ÒŽ˜¯å¦ç›¸½{‰ï¼Œ==操作½W¦æ˜¯ä¸ç®¡çš„ã€?br />
      理解final问题有很重要的含义。许多程序漏‹zžéƒ½åŸÞZºŽæ­?---final只能保证引用永远指向固定对象åQŒä¸èƒ½ä¿è¯é‚£ä¸ªå¯¹è±¡çš„状态不变。在多线½E‹çš„操作ä¸?一个对象会被多个线½E‹å…±äº«æˆ–修改åQŒä¸€ä¸ªçº¿½E‹å¯¹å¯¹è±¡æ— æ„è¯†çš„修改可能会导致另一个ä‹É用此对象的线½E‹å´©æºƒã€‚一个错误的解决æ–ÒŽ³•ž®±æ˜¯åœ¨æ­¤å¯¹è±¡æ–°å¾çš„时候把它声明äØ“finalåQŒæ„å›¾ä‹É得它“永远不变”。其实那是徒劳的ã€?br />
      问题五：到底要怎么样初始化åQ?/strong>

      本问题讨论变量的初始化，所以先来看一下Java中有哪些¿Uç±»çš„变量ã€?br />       1. ¾cȝš„属性，或者叫值域
      2. æ–ÒŽ³•é‡Œçš„局部变é‡?br />       3. æ–ÒŽ³•çš„参æ•?br />
      对于½W¬ä¸€¿Uå˜é‡ï¼ŒJava虚拟æœÞZ¼šè‡ªåŠ¨˜q›è¡Œåˆå§‹åŒ–。如果给å‡ÞZº†åˆå§‹å€û|¼Œåˆ™åˆå§‹åŒ–ä¸ø™¯¥åˆå§‹å€¹{€‚如果没有给出，则把它初始化ä¸ø™¯¥¾cÕdž‹å˜é‡çš„默认初始倹{€?br />
      int¾cÕdž‹å˜é‡é»˜è®¤åˆå§‹å€égØ“0
      float¾cÕdž‹å˜é‡é»˜è®¤åˆå§‹å€égØ“0.0f
      double¾cÕdž‹å˜é‡é»˜è®¤åˆå§‹å€égØ“0.0
      boolean¾cÕdž‹å˜é‡é»˜è®¤åˆå§‹å€égØ“false
      char¾cÕdž‹å˜é‡é»˜è®¤åˆå§‹å€égØ“0(ASCIIç ?
      long¾cÕdž‹å˜é‡é»˜è®¤åˆå§‹å€égØ“0
      所有对象引用类型变量默认初始å€égØ“nullåQŒå³ä¸æŒ‡å‘ä“Q何对象。注意数¾l„本íw«ä¹Ÿæ˜¯å¯¹è±¡ï¼Œæ‰€ä»¥æ²¡æœ‰åˆå§‹åŒ–çš„æ•°¾l„引用在自动初始化后其å€ég¹Ÿæ˜¯nullã€?br />
      对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创徏实例的时候初始化åQŒstatic属性在¾cÕdŠ è½½ï¼Œä¹Ÿå°±æ˜¯ç¬¬ä¸€‹Æ¡ç”¨åˆ°è¿™ä¸ªç±»çš„时候初始化åQŒå¯¹äºŽåŽæ¥çš„实例的创建，不再‹Æ¡è¿›è¡Œåˆå§‹åŒ–ã€?/font>˜q™ä¸ªé—®é¢˜ä¼šåœ¨ä»¥åŽçš„系列中˜q›è¡Œè¯¦ç»†è®¨è®ºã€?br />
      对于½W¬äºŒ¿Uå˜é‡ï¼Œå¿…须明确地进行初始化。如果再没有初始化之前就试图使用它，¾~–译器会抗议。如果初始化的语句在try块中或if块中åQŒä¹Ÿå¿…须要让它在½W¬ä¸€‹Æ¡ä‹É用前一定能够得到赋倹{€‚也ž®±æ˜¯è¯ß_¼ŒæŠŠåˆå§‹åŒ–语句攑֜¨åªæœ‰if块的条äšg判断语句中编译器也会抗议åQŒå› ä¸ºæ‰§è¡Œçš„时候可能不½W¦åˆif后面的判断条ä»Óž¼Œå¦‚此一来初始化语句ž®×ƒ¸ä¼šè¢«æ‰§è¡Œäº†ï¼Œ˜q™å°±˜qåäº†å±€éƒ¨å˜é‡ä‹É用前必须初始化的规定。但如果在else块中也有初始化语句，ž®±å¯ä»¥é€šè¿‡¾~–译åQŒå› ä¸ºæ— è®ºå¦‚何，æ€ÀLœ‰è‡›_°‘一条初始化语句会被执行åQŒä¸ä¼šå‘生ä‹É用前未被初始化的事情。对于try-catch也是一æ øP¼Œå¦‚果只有在try块里才有初始化语句，¾~–译部通过。如果在catch或finally里也有，则可以通过¾~–译。æ€ÖM¹‹åQŒè¦ä¿è¯å±€éƒ¨å˜é‡åœ¨ä½¿ç”¨ä¹‹å‰ä¸€å®šè¢«åˆå§‹åŒ–了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要å‡ÞZº‹åŒ–成什么值好åQŒå°±ç”¨ä¸Šé¢çš„默认值吧åQ?br />
      其实½W¬ä¸‰¿Uå˜é‡å’Œ½W¬äºŒ¿Uæœ¬è´¨ä¸Šæ˜¯ä¸€æ ïLš„åQŒéƒ½æ˜¯æ–¹æ³•ä¸­çš„局部变量。只不过作äؓ参数åQŒè‚¯å®šæ˜¯è¢«åˆå§‹åŒ–˜q‡çš„åQŒä¼ å…¥çš„值就是初始å€û|¼Œæ‰€ä»¥ä¸éœ€è¦åˆå§‹åŒ–ã€?br />
      问题六：instanceof是什么东东？

      instanceof是Java的一个二元操作符åQŒå’Œ==åQ?gt;åQ?lt;是同一¾cÖM¸œä¸œã€‚由于它是由字母¾l„成的，所以也是Java的保留关键字。它的作用是‹¹‹è¯•å®ƒå·¦è¾¹çš„对象是否是它双™¾¹çš„类的实例，˜q”回boolean¾cÕdž‹çš„数据。ä‹D个例子：

      String s = "I AM an Object!";
      boolean isObject = s instanceof Object;

      我们声明了一个String对象引用åQŒæŒ‡å‘一个String对象åQŒç„¶åŽç”¨instancof来测试它所指向的对象是否是Object¾cȝš„一个实例，昄¡„¶åQŒè¿™æ˜¯çœŸçš„，所以返回trueåQŒä¹Ÿž®±æ˜¯isObjectçš„å€égØ“Trueã€?br /> instanceof有一些用处。比如我们写了一个处理è̎单的¾pȝ»ŸåQŒå…¶ä¸­æœ‰˜q™æ ·ä¸‰ä¸ª¾c»ï¼š

      public class Bill {//省略¾l†èŠ‚}
      public class PhoneBill extends Bill {//省略¾l†èŠ‚}
      public class GasBill extends Bill {//省略¾l†èŠ‚}

      在处理程序里有一个方法，接受一个Bill¾cÕdž‹çš„对象，计算金额。假设两¿Uè̎单计½Ž—方法不同，而传入的Bill对象可能是两¿Uä¸­çš„ä“Q何一¿Uï¼Œæ‰€ä»¥è¦ç”¨instanceof来判断：

      public double calculate(Bill bill) {
         if (bill instanceof PhoneBill) {
           //计算电话账单
         }
         if (bill instanceof GasBill) {
           //计算燃气账单
         }
         ...
      }
      ˜q™æ ·ž®±å¯ä»¥ç”¨ä¸€ä¸ªæ–¹æ³•å¤„理两¿Uå­¾c…R€?br />
      然而，˜q™ç§åšæ³•é€šå¸¸è¢«è®¤ä¸ºæ˜¯æ²¡æœ‰å¥½å¥½åˆ©ç”¨é¢å‘对象中的多态性。其实上面的功能要求用方法重载完全可以实玎ͼŒ˜q™æ˜¯é¢å‘对象变成应有的做法，避免回到¾l“构化编½E‹æ¨¡å¼ã€‚只要提供两个名字和˜q”回值都相同åQŒæŽ¥å—参数类型不同的æ–ÒŽ³•ž®±å¯ä»¥äº†åQ?br />
      public double calculate(PhoneBill bill) {
         //计算电话账单
      }

      public double calculate(GasBill bill) {
         //计算燃气账单
      }

      所以，使用instanceof在绝大多数情况下òq¶ä¸æ˜¯æŽ¨èçš„做法åQŒåº”当好好利用多态ã€?/font>



]]>语言深入:java中究竟是传å€ÆD¿˜æ˜¯ä¼ å¼•ç”¨http://www.aygfsteel.com/alinglau36/archive/2009/03/24/261747.htmllaulauTue, 24 Mar 2009 10:21:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2009/03/24/261747.htmlhttp://www.aygfsteel.com/alinglau36/comments/261747.htmlhttp://www.aygfsteel.com/alinglau36/archive/2009/03/24/261747.html#Feedback5http://www.aygfsteel.com/alinglau36/comments/commentRss/261747.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/261747.html首先åQŒæŽ¨èå¯¹Java有一定理解的同仁一本书《Practical Java》。在《Practical Java》中也有一个章节介¾lJava中关于传值和传引用的问题åQŒå ª¿U°ç»å…¸ã€‚《Practical Java》在Java中，事实上底层工作原理不存在传引用的概念åQŒè¿™ä¹Ÿè±¡ã€ŠPractical Java》中所说的那样åQŒJava中只有传倹{€‚这句话理解èµäh¥éœ€è¦è´¹ä¸€å®šçš„周折ã€?/font>

      熟悉C的程序员都用˜q‡æŒ‡é’ˆï¼Œå¯ÒŽŒ‡é’ˆå¯è°“爱之深恨之切。指针是指向一块内存地址的内存数据（有些拗口åQ‰ï¼Œä¹Ÿå°±æ˜¯è¯´æŒ‡é’ˆæœ¬èín是一个占ç”?字节内存的intåQ?2 位系¾lŸå†…åQ‰ï¼Œè€Œè¿™ä¸ªint值恰恰又是另一块内存的地址。比å¦?hello"˜q™ä¸ªå­—串åQŒå­˜æ”‘Öœ¨@0x0000F000˜q™ä¸ªåœ°å€åˆ°@0x0000F005˜q™æ®µå†…存区域内（包括0x00的结束字节）。而在@0x0000FFF0到@0x0000FFF03˜q™å››ä¸ªå­—节内存放着一个intåQŒè¿™ä¸ªint的值是 @0x0000F000。这样就形成了一个指å?hello"字串的指针ã€?/font>

      在Java中，很多äºø™¯´æ²¡æœ‰æŒ‡é’ˆåQŒäº‹å®žä¸ŠåQŒåœ¨Java更深层次里，到处都是大师ž®è£…好的¾_„¡¾Ž¾läëu的指针ã€?/font>ä¸ÞZº†æ›´å®¹æ˜“的讲解Java中关于类和类型的调用åQŒJava中出çŽîCº†å€ég¸Žå¼•ç”¨çš„说法。浅昄¡š„来说åQŒæˆ‘们可以认为Java中的引用与C中的指针½{‰æ•ˆåQˆå…¶å®žå·®åˆ«éžå¸”Ržå¸¸å¤§åQŒä½†æ˜¯äؓ了说明我们今天的问题åQŒæŠŠä»–们理解为等效是没有ä»ÖM½•é—®é¢˜çš„）ã€?/font>

      所谓传引用的说法是ä¸ÞZº†æ›´å¥½çš„讲解调用方式。基于上面对指针的理解，我们不难看出åQŒæŒ‡é’ˆå…¶å®žä¹Ÿæ˜¯ä¸€ä¸ªintå€û|¼Œæ‰€è°“传引用åQŒæˆ‘们是复制了复制了指针的intå€ÆD¿›è¡Œä¼ é€’。äؓ了便于理解，我们可以姑且把指针看作一¿Uæ•°æ®ç±»åž‹ï¼Œé€æ˜ŽåŒ–指针的intç‰ÒŽ€§ï¼Œä»Žè€Œæå‡ÞZ¼ å¼•ç”¨çš„概å¿üc€?/font>

      重申一遍：Java中只有传倹{€?/strong>

      1所谓传值和传引ç”?/strong>

      传值和传引用的问题一直是Java里争论的话题。与C++不同的，Java里面没有指针的概念，Java的设计者åéy妙的å¯ÒŽŒ‡é’ˆçš„操作˜q›è¡Œäº†ç®¡ç†ã€‚事实上åQŒåœ¨æ‡‚C++çš„Java½E‹åºå‘˜çœ¼ä¸­ï¼ŒJava到处都是¾_„¡¾Ž¾läëu的指针ã€?br /> 下面举个½Ž€å•çš„例子åQŒè¯´æ˜Žä»€ä¹ˆæ˜¯ä¼ å€û|¼Œä»€ä¹ˆæ˜¯ä¼ å¼•ç”¨ã€?br /> //ä¾?
void method1(){
int x=0;
this.change(x);
System.out.println(x);
}

void change(int i){
i=1;
}

      很显然的åQŒåœ¨mothod1中执行了change(x)后，x的值åƈ不会因äØ“changeæ–ÒŽ³•ä¸­å°†è¾“入参数赋å€égØ“1而变æˆ?åQŒä¹Ÿž®±æ˜¯è¯´åœ¨æ‰§è¡Œchange(x)后，x的值z依然æ˜?。这是因为x传递给change(int i)的是倹{€‚è¿™ž®±æ˜¯æœ€½Ž€å•çš„传倹{€?br /> 同样的，˜q›è¡Œä¸€ç‚¹ç®€å•çš„变化ã€?br /> //ä¾?
void method1(){
StringBuffer x=new StringBuffer("Hello");
this.change(x);
System.out.println(x);
}

void change(StringBuffer i){
i.append(" world!");
}
      看è“v来没什么变化，但是˜q™æ¬¡mothed1中执行了change (x)后，xçš„å€ég¸å†æ˜¯"Hello"了，而是变成äº?Hello world!"。这是因为x传递给change(i)的是x的引用。这是最¾lå…¸çš„传引用ã€?br /> ä¼ég¹Žæœ‰äº›å¥‡æ€ªäº†åQŒä¸¤ŒD늨‹åºæ²¡æœ‰ç‰¹åˆ«çš„不同åQŒå¯æ˜¯äؓ什么一个传的是å€ÆD€Œå¦ä¸€ä¸ªä¼ çš„是引用呢？......

      2非要搞清楚传å€ÆD¿˜æ˜¯ä¼ å¼•ç”¨çš„问题吗åQ?/strong>

      搞清楚这自然是有必要的，不然我也不需要写˜q™ä¹ˆå¤šäº†åQŒä¸˜q‡çš„¼‹®æ²¡æœ‰åˆ°"非要"的地步ã€?/font>


      首先åQŒå¦‚果我们不太关心什么是传å€ég»€ä¹ˆæ˜¯ä¼ å¼•ç”¨ï¼Œæˆ‘们一栯‚ƒ½å†™å‡ºæ¼‚亮的代码，但是˜q™äº›ä»£ç åœ¨è¿è¡Œè¿‡½E‹ä¸­å¯èƒ½ä¼šå­˜åœ¨ç€æžå¤§çš„隐患。全局变量是让大家深恶痛绝åQˆåˆéš¾ä»¥å‰²èˆåQ‰çš„东西åQŒåŽŸå› å°±æ˜¯ä‹É用全局变量要特别注意数据的保护。如果在多线½E‹çš„½E‹åºé‡Œä‹É用全局变量½Ž€ç›´å°±½{‰äºŽè·Ÿè‡ªå·Þp¿‡ä¸åŽ»ã€‚不了解传值和传引用的问题åQŒè·Ÿä½¿ç”¨å…¨å±€å˜é‡ä¸è€ƒè™‘数据保护的罪˜q‡æ˜¯ä¸ç›¸ä¸Šä¸‹ä¸‹çš„åQŒç”šè‡Ïxœ‰æ—¶å€™æ¯”它还要糟。你会莫名其妙，ä¸ÞZ»€ä¹ˆæˆ‘的返回参数没有è“v作用åQŒäؓ什么我传进åŽÈš„参数变成了这æ ?.....åQ?br /> 一个例子：
//ä¾?
void mothed1(){
int x=0;
int y=1;
switchValue(x,y);
System.out.println("x="+x);
System.out.println("y="+y);
}
void switchValue(int a,int b){

int c=a;
a=b;
b=c;
}
      上面是一个交换a,b值的函数åQŒçœ‹èµäh¥ä¼ég¹Žè›®æ­£¼‹®çš„åQŒä½†æ˜¯è¿™ä¸ªå‡½æ•°æ°¸˜qœä¹Ÿä¸ä¼šå®Œæˆä½ æƒ³è¦çš„工作ã€?br />       ˜q˜æœ‰ä¸€ä¸ªä¾‹å­ï¼š
//ä¾?
StringBuffer a=new StringBuffer("I am a ");
StringBuffer b=a;
a.append("after append");
a=b;
System.out.println("a="+a);
在编½E‹è¿‡½E‹ä¸­åQŒç»å¸æ€¼šé‡åˆ°˜q™ç§æƒ…况åQŒä¸€ä¸ªå˜é‡çš„å€ÆD¦è¢«äÍ时改变一下，½{‰ç”¨å®Œä¹‹åŽå†æ¢å¤åˆ°å¼€å§‹çš„倹{€‚就好像上面的例子，aä¸ÞZº†ä¿æŒå®ƒçš„å€û|¼Œä½¿ç”¨b=a做赋å€û|¼Œä¹‹åŽa被改变，再之后a把暂存在b里面的值取回来。这是我们一厢情愿的æƒÏx³•åQŒè€Œäº‹å®žä¸ŠåQŒè¿™ŒDµä»£ç æ‰§è¡ŒåŽåQŒä½ ä¼šå‘现a的值已¾læ”¹å˜äº†ã€?br /> 以上是两个最½Ž€å•çš„例子åQŒçœŸæ­£çš„½E‹åºå¼€å‘过½E‹ä¸­åQŒæ¯”˜q™è¦å¤æ‚的情冉|¯å¤©éƒ½ä¼šé‡åˆ°ã€?/font>

      3¾cÕdž‹å’Œç±»

      Java 提出的思想åQŒåœ¨Java里面ä»ÖM½•ä¸œè¥¿éƒ½æ˜¯¾c…R€‚但是Java里面同时˜q˜æœ‰½Ž€å•æ•°æ®ç±»åž‹int,byte,char,booleanåQŒä¸Ž˜q™äº›æ•°æ®¾cÕdž‹ç›¸å¯¹åº”çš„¾cÀL˜¯IntegeråQŒByteåQŒCharacteråQŒBooleanåQŒè¿™æ ·åšä¾ç„¶ä¸ä¼šç ´åJava关于ä»ÖM½•ä¸œè¥¿éƒ½æ˜¯¾cȝš„提法。这里提到数据类型和¾cÖM¼¼ä¹Žå’Œæˆ‘们要说的传值和传引用的问题无关åQŒä½†˜q™æ˜¯æˆ‘们分èöL传值和传引用的基础ã€?/font>

      4试图分èöLä¼ å€ÆD¿˜æ˜¯ä¼ å¼•ç”¨

      ä¸ÞZ»€ä¹ˆæ˜¯"试图分èöL"呢？很简单，传值和传引用的问题无处不在åQŒä½†æ˜¯ä¼¼ä¹Žè¿˜æ²¡æœ‰äºø™ƒ½æ­£ç»Ÿçš„给出标准，怎样的就是值拷贝调用，怎样的就是引用调用。面对这个问题，我们更多的应该是来自òqÏx—¶¿U¯ç¯å¯¹Java的理解ã€?br />       回过头来åQŒæˆ‘们分析一下上面的几个例子åQ?br />       先看ä¾?åQŒå³ä½¿ä½ ä¸æ˜Žç™½äؓ什么，但是你应该知道这样做肯定不会改变x的倹{€‚äؓ了方便说明，我们¾l™ä¾‹å­éƒ½åŠ ä¸Šè¡Œå·ã€?br /> //ä¾?
1 void method1(){
2   int x=0;
3   this.change(x);
4 }
5
6 void change(int i){
7 i=7;
8}
      让我们从内存的存储方式看一下xå’ŒI之间到底是什么关¾p…R€?br />       在执行到½W?行的时候，变量x指向一个存攄¡€int 0的内存地址ã€?/font>

      变量x---->[存放å€?]

      执行½W?行调用change(x)æ–ÒŽ³•çš„时候，内存中是˜q™æ ·çš„情形：x把自己值在内存中复制一份，然后变量i指向˜q™ä¸ªè¢«å¤åˆ¶å‡ºæ¥çš„0ã€?/font>

      变量x---->[存放å€?]
                        ↓˜q›è¡Œäº†ä¸€‹Æ¡å€¼å¤åˆ?br />       变量x---->[存放å€?]

      ˜q™æ—¶å€™å†æ‰§è¡Œåˆ°ç¬¬7行的时候，变量i的被赋å€égØ“7åQŒè€Œè¿™ä¸€æ­¥çš„操作已经跟x没有ä»ÖM½•å…³ç³»äº†ã€?/font>

      变量x---->[存放å€?]
             
      变量x---->[存放å€?]

      说到˜q™é‡Œåº”该已经理解ä¸ÞZ»€ä¹ˆchange(x)不能改变xçš„å€égº†å§ï¼Ÿå› äØ“˜q™ä¸ªä¾‹å­æ˜¯ä¼ å€¼çš„ã€?br /> 那么åQŒè¯•ç€åˆ†æžä¸€ä¸‹äؓ什么例三中的switchValue()æ–ÒŽ³•ä¸èƒ½å®Œæˆå˜é‡å€égº¤æ¢çš„工作åQ?br /> 再看ä¾?ã€?br /> //ä¾?
1void method1(){
2 StringBuffer x=new StringBuffer("Hello");
3 this.change(x);
4}
5
6void change(StringBuffer i){
7 i.append(" world!");
8}
      ä¾?ä¼ég¹Žå’Œä¾‹1从代码上看不å‡ÞZ»€ä¹ˆå·®åˆ«ï¼Œä½†æ˜¯æ‰§è¡Œ¾l“果却是change(x)能改变x的倹{€‚依然才从内存的存储角度来看看例2的蹊跷在哪里ã€?br /> 在执行到½W?行时候，同例1一æ øP¼Œx指向一个存æ”?Hello"的内存空间ã€?/font>

      变量x---->[存放å€?Hello"]

      接下来执行第三行change(x)åQŒæ³¨æ„ï¼Œ˜q™é‡Œž®×ƒ¸Žä¾?有了本质的不同：调用change(x)æ—Óž¼Œå˜é‡i也指向了x指向的内存空é—ß_¼Œè€Œä¸æ˜¯æŒ‡å‘x的一个拷贝ã€?/font>

      变量x "
              -->[存放å€?Hello"]
      变量x /

      于是åQŒç¬¬7行对i调用appendæ–ÒŽ³•åQŒæ”¹å˜i指向的内存空间的å€û|¼Œxçš„å€ég¹Ÿž®±éšä¹‹æ”¹å˜äº†ã€?/font>

      变量x "
              -->[˜q½åŠ ä¸?Hello World!"]
      变量x /

      ä¸ÞZ»€ä¹ˆxå€ÆDƒ½æ”¹å˜å‘¢ï¼Ÿå› äØ“˜q™ä¸ªä¾‹å­æ˜¯ä¼ å¼•ç”¨çš„ã€?br /> ˜q™å‡ ä¸ªä¾‹å­æ˜¯æ˜Žç™½äº†ï¼Œå¯æ˜¯å¾ˆå¤šäºÞZ¼šå¼€å§‹æœ‰å¦ä¸€ä¸ªç–‘问了åQšè¿™æ ïLœ‹æ¥ï¼Œåˆ°åº•ä»€ä¹ˆæ—¶å€™æ˜¯ä¼ çš„å€ég»€ä¹ˆæ—¶å€™æ˜¯ä¼ å¾—引用呢？于是åQŒæˆ‘们前面讲到的¾cÕdž‹å’Œç±»åœ¨è¿™é‡Œå°±‹z¾ä¸Šäº†ç”¨åœ?strong>åQ?font color="#ff0000">对于参数传递，如果是简单数据类型，那么它传递的是值拷贝，对于¾cȝš„实例它传递的是类的引用。需要注意的是，˜q™æ¡è§„则只适用于参æ•îC¼ é€’ã€?/font>ä¸ÞZ»€ä¹ˆè¿™ä¹ˆè¯´å‘¢ï¼Ÿæˆ‘们看看˜q™æ ·ä¸€ä¸ªä¾‹å­ï¼š
//ä¾?
String str="abcdefghijk";
str.replaceAll("b","B");
      ˜q™ä¸¤å¥æ‰§è¡ŒåŽåQŒstr的内容依然是"abcdefghijk"åQŒä½†æ˜¯æˆ‘们明明是对str操作的，ä¸ÞZ»€ä¹ˆæ˜¯˜q™æ ·çš„å‘¢åQŸå› ä¸ºstr的值究竟会不会被改变完全取决于replaceAll˜q™ä¸ªæ–ÒŽ³•æ˜¯æ€Žä¹ˆå®žçŽ°çš„。类似的åQŒæœ‰˜q™æ ·ä¸€ä¸ªä¾‹å­ï¼š
//ä¾?
1 void method1() {
2 StringBuffer x = new StringBuffer("Hello");
3 change1(x);
4 System.out.println(x);
5 }
6
7 void method2() {
8 StringBuffer x = new StringBuffer("Hello");
9 change2(x);
10 System.out.println(x);
11 }
12
13 void change1(StringBuffer sb) {
14 sb.append(" world!");
15 }
16
17 void change2(StringBuffer sb) {
18 sb = new StringBuffer("hi");
19 sb.append(" world!");
20 }
      调用method1()åQŒå±òq•æ‰“印结果äØ“åQ?Hello world!"
调用method2()åQŒæˆ‘们认为结果应该是"hi world"åQŒå› ä¸ºsb传进来的是引用。可是实际执行的¾l“æžœæ˜?Hello"åQ?br /> éšùN“change2()又变成传å€égº†åQŸï¼å…¶å®žchange1()å’Œchange2()的确都是通过参数传入引用åQŒä½†æ˜¯åœ¨æ–ÒŽ³•å†…部因äؓ处理æ–ÒŽ³•çš„不同而ä‹É¾l“果大相径庭。我们还是从内存的角度分析：
执行method1()å’Œchange1()不用再多说了åQŒä¸Šé¢çš„例子已经讲解˜q‡ï¼Œ˜q™é‡Œæˆ‘们分析一下method2()å’Œchange2()ã€?br />       ½E‹åºæ‰§è¡Œåˆ°ç¬¬8行，x指向一个存攄¡€"Hello"的内存空间ã€?/font>

      变量x---->[存放å€?Hello"]

      ½W?行调用change2åQŒå°†sb指向x指向的内存空é—ß_¼Œä¹Ÿå°±æ˜¯ä¼ å…¥x的引用ã€?/font>

      变量x "
              -->[存放å€?Hello"]
      变量x /

      到这里äؓ止还没有什么异æ øP¼ŒæŽ¥ä¸‹æ¥æ‰§è¡?8行，˜q™é‡Œž®±å‡ºçŽîCº†¾cÖM¼¼ä¼ å…¥å€¼æ‹·è´çš„变化åQšnew æ–ÒŽ³•òq¶æ²¡æœ‰æ”¹å˜sb指向内存的内容，而是在内从中开辟了一块新的空间存放串"hi"åQŒåŒæ—¶sb指向了这块空间ã€?/font>

      变量x---->[存放å€?Hello"]
            ×原有的引用被切断
      变量x---->[另一块存æ”?hi"的空间]

      接下来再对sb˜q›è¡Œappend已经和x没有ä»ÖM½•å…³ç³»äº†ã€?br /> 所以，˜q˜æœ‰ä¸€æ¡ä¸æˆè§„则的规则åQšå¯¹äºŽå‡½æ•°è°ƒç”¨ï¼Œæœ€¾lˆæ•ˆæžœæ˜¯ä»€ä¹ˆå®Œå…¨çœ‹å‡½æ•°å†…部的实现。比较标准的做法是如果会改变引用的内容，则ä‹É用void作äØ“æ–ÒŽ³•˜q”回å€û|¼Œè€Œä¸ä¼šæ”¹å˜å¼•ç”¨å†…容的则在˜q”回å€ég¸­˜q”回新的倹{€?br /> 虽然已经说了˜q™ä¹ˆå¤šï¼Œä½†æ˜¯æ„Ÿè§‰ä¼ å€ÆD¿˜æ˜¯ä¼ å¼•ç”¨çš„问题依然没有完全说清楚。因ä¸ø™¿™ä¸ªé—®é¢˜æœ¬íw«å°±æ˜¯å¾ˆéš‘Ö½’¾UÏx€È»“的问题，所以更多的理解要靠òqÏx—¶çš„积累和形成。下面几个例子，¾l™å¤§å®¶å°è¯•è¿›è¡Œåˆ†æžã€?br /> //ä¾?åQŒæ‰“印结果是什么？
public static void main(String[] args) {
int a;
int b;
StringBuffer c;
StringBuffer d;
a = 0;
b = a;
c = new StringBuffer("This is c");
d = c;

a = 2;
c.append("!!");

System.out.println("a=" + a);
System.out.println("b=" + b);
System.out.println("c=" + c);
System.out.println("d=" + d);
}

//ä¾?åQŒæ‰“印结果是什么？
public class Test{

        public static void main(String[] args) {

         StringBuffer sb = new StringBuffer("Hello ");

         System.out.println("Before change, sb = " + sb);

         changeData(sb);

         System.out.println("After changeData(n), sb = " + sb);

     }

     

        public static void changeData(StringBuffer strBuf) {

            StringBuffer sb2 = new StringBuffer("Hi ");

            strBuf = sb2;

            sb2.append("World!");

     }

}

如果本文å¯ÒŽ‚¨æœ‰å¸®åŠ©åƈ且要鼓励我的话，è¯äh‰«æå¦‚下二¾l´ç æ”¯æŒæœ¬äh的劳动成果，多谢了！




]]>System.getProperty()http://www.aygfsteel.com/alinglau36/archive/2009/03/16/260021.htmllaulauMon, 16 Mar 2009 06:54:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2009/03/16/260021.htmlhttp://www.aygfsteel.com/alinglau36/comments/260021.htmlhttp://www.aygfsteel.com/alinglau36/archive/2009/03/16/260021.html#Feedback0http://www.aygfsteel.com/alinglau36/comments/commentRss/260021.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/260021.htmlSystem.getProperty()
 1public class Information {   
 2    public static void main(String args[]) {   
 3        System.out.println("java_vendor:" + System.getProperty("java.vendor"));   
 4        System.out.println("java_vendor_url:"   
 5                + System.getProperty("java.vendor.url"));   
 6        System.out.println("java_home:" + System.getProperty("java.home"));   
 7        System.out.println("java_class_version:"   
 8                + System.getProperty("java.class.version"));   
 9        System.out.println("java_class_path:"   
10                + System.getProperty("java.class.path"));   
11        System.out.println("os_name:" + System.getProperty("os.name"));   
12        System.out.println("os_arch:" + System.getProperty("os.arch"));   
13        System.out.println("os_version:" + System.getProperty("os.version"));   
14        System.out.println("user_name:" + System.getProperty("user.name"));   
15        System.out.println("user_home:" + System.getProperty("user.home"));   
16        System.out.println("user_dir:" + System.getProperty("user.dir"));   
17        System.out.println("java_vm_specification_version:"   
18                + System.getProperty("java.vm.specification.version"));   
19        System.out.println("java_vm_specification_vendor:"   
20                + System.getProperty("java.vm.specification.vendor"));   
21        System.out.println("java_vm_specification_name:"   
22                + System.getProperty("java.vm.specification.name"));   
23        System.out.println("java_vm_version:"   
24                + System.getProperty("java.vm.version"));   
25        System.out.println("java_vm_vendor:"   
26                + System.getProperty("java.vm.vendor"));   
27        System.out   
28                .println("java_vm_name:" + System.getProperty("java.vm.name"));   
29        System.out.println("java_ext_dirs:"   
30                + System.getProperty("java.ext.dirs"));   
31        System.out.println("file_separator:"   
32                + System.getProperty("file.separator"));   
33        System.out.println("path_separator:"   
34                + System.getProperty("path.separator"));   
35        System.out.println("line_separator:"   
36                + System.getProperty("line.separator"));   
37    }   
38}   
39
常用的System.getProperty()åQŒè¿™é‡Œè„“一下，省得下次éºÈƒ¦.

From jdk 1.5.0 documents

java.version

Java ˜qè¡Œæ—¶çŽ¯å¢ƒç‰ˆæœ?/span>

java.vendor

Java ˜qè¡Œæ—¶çŽ¯å¢ƒä¾›åº”商

java.vendor.url

Java 供应商的 URL

java.home

Java 安装目录

java.vm.specification.version

Java 虚拟æœø™§„范版æœ?/span>

java.vm.specification.vendor

Java 虚拟æœø™§„范供应商

java.vm.specification.name

Java 虚拟æœø™§„范名¿U?/span>

java.vm.version

Java 虚拟机实现版�/span>

java.vm.vendor

Java 虚拟机实çŽîC¾›åº”商

java.vm.name

Java 虚拟机实现名¿U?/span>

java.specification.version

Java ˜qè¡Œæ—¶çŽ¯å¢ƒè§„范版æœ?/span>

java.specification.vendor

Java ˜qè¡Œæ—¶çŽ¯å¢ƒè§„范供应商

java.specification.name

Java ˜qè¡Œæ—¶çŽ¯å¢ƒè§„范名¿U?/span>

java.class.version

Java ¾cÀL ¼å¼ç‰ˆæœ¬å·

java.class.path

Java ¾c»èµ\å¾?/span>

java.library.path

加蝲库时搜烦的èµ\径列è¡?/span>

java.io.tmpdir

默认的äÍ时文件èµ\å¾?/span>

java.compiler

要ä‹É用的 JIT ¾~–译器的名称

java.ext.dirs

一个或多个扩展目录的èµ\å¾?/span>

os.name

操作¾pȝ»Ÿçš„名¿U?/span>

os.arch

操作¾pȝ»Ÿçš„架æž?/span>

os.version

操作¾pȝ»Ÿçš„版æœ?/span>

file.separator

æ–‡äšg分隔½W¦ï¼ˆåœ?UNIX ¾pȝ»Ÿä¸­æ˜¯“/”åQ?/span>

path.separator

路径分隔½W¦ï¼ˆåœ?UNIX ¾pȝ»Ÿä¸­æ˜¯“:”åQ?/span>

line.separator

行分隔符åQˆåœ¨ UNIX ¾pȝ»Ÿä¸­æ˜¯“/n”åQ?/span>

user.name

用户的è̎户名¿U?/span>

user.home

用户的主目录

user.dir

用户的当前工作目�/span>


¾pȝ»Ÿå±žæ€§å€ég¸­çš„多个èµ\径是用åã^台的路径分隔½W¦åˆ†éš”çš„


]]>java需要了解的东西http://www.aygfsteel.com/alinglau36/archive/2009/03/02/257337.htmllaulauMon, 02 Mar 2009 06:32:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2009/03/02/257337.htmlhttp://www.aygfsteel.com/alinglau36/comments/257337.htmlhttp://www.aygfsteel.com/alinglau36/archive/2009/03/02/257337.html#Feedback0http://www.aygfsteel.com/alinglau36/comments/commentRss/257337.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/257337.html阅读全文

]]>java中static的作ç”?http://www.aygfsteel.com/alinglau36/archive/2009/03/02/257313.htmllaulauMon, 02 Mar 2009 04:03:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2009/03/02/257313.htmlhttp://www.aygfsteel.com/alinglau36/comments/257313.htmlhttp://www.aygfsteel.com/alinglau36/archive/2009/03/02/257313.html#Feedback0http://www.aygfsteel.com/alinglau36/comments/commentRss/257313.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/257313.html有时你希望定义一个类成员åQŒä‹É它的使用完全独立于该¾cȝš„ä»ÖM½•å¯¹è±¡ã€‚通常情况下，¾cÀLˆå‘˜å¿…™å»é€šè¿‡å®ƒçš„¾cȝš„对象讉K—®åQŒä½†æ˜¯å¯ä»¥åˆ›å»ø™¿™æ ·ä¸€ä¸ªæˆå‘˜ï¼Œå®ƒèƒ½å¤? 被它自己使用åQŒè€Œä¸å¿…引用特定的实例。在成员的声明前面加上关键字static(静态的)ž®Þpƒ½åˆ›å¾˜q™æ ·çš„成员。如果一个成员被声明为staticåQŒå®ƒž®Þpƒ½ 够在它的¾cȝš„ä»ÖM½•å¯¹è±¡åˆ›å¾ä¹‹å‰è¢«è®¿é—®ï¼Œè€Œä¸å¿…引用ä“Q何对象。你可以ž®†æ–¹æ³•å’Œå˜é‡éƒ½å£°æ˜ŽäØ“static。static 成员的最常见的例子是main( ) 。因为在½E‹åºå¼€å§‹æ‰§è¡Œæ—¶å¿…须调用main() åQŒæ‰€ä»¥å®ƒè¢«å£°æ˜ŽäØ“staticã€?

声明为static的变量实质上ž®±æ˜¯å…¨å±€å˜é‡ã€‚当声明一个对象时åQŒåƈ不äñ”生static变量的拷贝，而是该类所有的实例变量å…Þq”¨åŒä¸€ä¸ªstatic变量。声明äØ“static的方法有以下几条限制åQ?
·
它们仅能调用其他的static æ–ÒŽ³•ã€?
·
它们只能讉K—®static数据ã€?
·
它们不能以ä“Q何方式引用this 或superåQˆå…³é”®å­—super 与ç‘ô承有养I¼Œåœ¨ä¸‹ä¸€ç« ä¸­æè¿°åQ‰ã€?
如果你需要通过计算来初始化你的static变量åQŒä½ å¯ä»¥å£°æ˜Žä¸€ä¸ªstatic块，Static 块仅在该¾c»è¢«åŠ è²æ—¶æ‰§è¡Œä¸€‹Æ¡ã€‚下面的例子昄¡¤ºçš„类有一个staticæ–ÒŽ³•åQŒä¸€äº›static变量åQŒä»¥åŠä¸€ä¸ªstatic 初始化块åQ?
// Demonstrate static variablesåQŒmethodsåQŒand blocks.

class UseStatic {
static int a = 3;
static int b;


static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);


}

static {
System.out.println("Static block initialized.");
b = a * 4;


}

public static void main(String args[]) {
meth(42);
}
}


一旦UseStatic ¾c»è¢«è£…蝲åQŒæ‰€æœ‰çš„static语句被运行。首先，a被设¾|®äØ“3åQŒæŽ¥ç€static 块执è¡?打印一条消æ?åQŒæœ€åŽï¼Œb被初始化为a*4 æˆ?2。然后调用main()åQŒmain() 调用meth() åQŒæŠŠå€?2传递给xã€?个println ( ) 语句引用两个static变量aå’ŒbåQŒä»¥åŠå±€éƒ¨å˜é‡x ã€?

注意åQšåœ¨ä¸€ä¸ªstatic æ–ÒŽ³•ä¸­å¼•ç”¨ä“Q何实例变量都是非法的ã€?

下面是该½E‹åºçš„输出：

Static block initialized.
x = 42
a = 3
b = 12
在定义它们的¾cȝš„外面åQŒstatic æ–ÒŽ³•å’Œå˜é‡èƒ½ç‹¬ç«‹äºŽä“Q何对象而被使用。这æ øP¼Œä½ åªè¦åœ¨¾cȝš„名字后面加点可‚¿½Ž—符卛_¯ã€‚例如，如果你希望从¾cÕd¤–面调用一个staticæ–ÒŽ³•åQŒä½ å¯ä»¥ä½¿ç”¨ä¸‹é¢é€šç”¨çš„格式：

classname.method( )

˜q™é‡ŒåQŒclassname 是类的名字，在该¾cÖM¸­å®šä¹‰staticæ–ÒŽ³•ã€‚可以看刎ͼŒ˜q™ç§æ ¼å¼ä¸Žé€šè¿‡å¯¹è±¡å¼•ç”¨å˜é‡è°ƒç”¨éžstaticæ–ÒŽ³•çš„格式类伹{€‚一个static变量可以以同æ ïLš„ 格式来访问——类名加点号˜qç®—½W¦ã€‚è¿™ž®±æ˜¯Java 如何实现全局功能和全局变量的一个控制版本ã€?

下面是一个例子。在main() 中，staticæ–ÒŽ³•callme() å’Œstatic 变量b在它们的¾cÖM¹‹å¤–被讉K—®ã€?

class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {


System.out.println("a = " + a);
}
}


class StaticByName {

public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);


}
}

下面是该½E‹åºçš„输出：

a = 42
b = 99


 

static成员是不能被其所在class创徏的实例访问的�/p>

如果不加static修饰的成员是对象成员åQŒä¹Ÿž®±æ˜¯å½’每个对象所有的ã€?

加static修饰的成员是¾cÀLˆå‘˜ï¼Œž®±æ˜¯å¯ä»¥ç”׃¸€ä¸ªç±»ç›´æŽ¥è°ƒç”¨åQŒäؓ所有对象共有的

]]>如何避免在Java中ä‹É用Checked Exceptionhttp://www.aygfsteel.com/alinglau36/archive/2009/02/17/255045.htmllaulauTue, 17 Feb 2009 03:18:00 GMThttp://www.aygfsteel.com/alinglau36/archive/2009/02/17/255045.htmlhttp://www.aygfsteel.com/alinglau36/comments/255045.htmlhttp://www.aygfsteel.com/alinglau36/archive/2009/02/17/255045.html#Feedback1http://www.aygfsteel.com/alinglau36/comments/commentRss/255045.htmlhttp://www.aygfsteel.com/alinglau36/services/trackbacks/255045.html如何避免在Java中ä‹É用Checked Exception

发布旉™—´åQ?007.08.20 08:52     来源åQšèµ›˜qªç½‘    ä½œè€…：dxaw

˜q? ½‹‡æ–‡ç« æŒ‡å‡ÞZº†Java中checked Exception的一些缺点，提出应该在程序设计中避免使用checked Exception,对于需要处理checked Exception的代码，可以使用ExceptionAdapter˜q™ä¸ª¾cÕd¯¹checked Exception˜q›è¡ŒåŒ…装。这½‹‡æ–‡ç« çš„概念和ExceptionAdapter˜q™ä¸ª¾cÕd‡æºè‡ªBruce Eckelçš„Does Java need Checked Exceptionã€?

Javaçš„Exception分äؓ两类åQŒä¸€¾cÀL˜¯RuntimeExceptionå? 其子¾c»ï¼Œå¦å¤–一¾cÕd°±æ˜¯checked Exception。Java要求函数å¯ÒŽ²¡æœ‰è¢«catch处理掉的checked ExceptionåQŒéœ€è¦å°†å…¶å†™åœ¨å‡½æ•°çš„声明部分。然而，˜q™ä¸€è¦æ±‚常常¾l™ç¨‹åºå‘˜å¸¦æ¥ä¸€äº›ä¸å¿…要的负担ã€?

ä¸ÞZº†é¿å…åœ¨å‡½æ•°å£°æ˜Žä¸­å†™throws部分åQŒåœ¨Java™å¹ç›®é‡Œé¢å¸¸å¸¸å¯ä»¥çœ‹åˆ°ä»¥ä¸‹ä»£ç ç”¨æ¥‘吞掉’ExceptionåQ? 

try {

            

            

            

            // ...

            

            

            

            } catch (Exception ex) {

            

            

            

            ex.printStackTrace(); 

            

            

            

            }

˜q™æ˜¾ç„¶ä¸æ˜¯ä¸€ä¸ªå¥½çš„处理Exception办法åQŒäº‹å®žä¸ŠåQŒcatchòq¶å¤„理一个Exception意味着让程序从发生的错è¯?Exception)中恢复过来。从˜q™ç§æ„ä¹‰ä¸Šè¯´åQŒå·²ä¸Šçš„代码只可能在一些很½Ž€å•çš„情况下工作而不带来问题ã€?

对于很多ExceptionåQŒå¾€å¾€æ²¡æœ‰åŽÕd¤„理它òq¶è®©½E‹åºä»Žé”™è¯¯ä¸­æ¢å¤å‡ºæ¥çš„办法，˜q? 时唯一能做的事情可能就是在界面上显½CÞZ¸€äº›æ½CÞZ¿¡æ¯ç»™ç”¨æˆ·ã€‚è¿™¿Uæƒ…况下让程序抛出遇到的Exception是更为合理的做法。然而，˜q™æ ·åšä¼šä½¿å¾—一些函æ•? 的声明急剧膨胀。一个函数可能需要声明会抛出çš?ã€?个checked ExceptionåQŒè€Œä¸”每个调用它的函数也需要同æ ïLš„声明ã€?

比这更糟¾p•çš„是，˜q™æœ‰å¯èƒ½ç ´å¾c»è®¾è®¡çš„open-close原则。简单来 è¯ß_¼Œopen-close原则是指当扩展一个模块的时候，可以不媄响其现有的client。open-close原则是通过¾l§æ‰¿æ¥å®žçŽ°çš„åQŒå½“¾l§æ‰¿ä¸€ä¸ªç±»çš? 时候，我们既扩展了˜q™ä¸ª¾c»ï¼Œä¹Ÿä¸ä¼šåª„响原有的clientåQˆå› ä¸ºå¯¹˜q™ä¸ª¾cÀL²¡æœ‰æ”¹åŠ¨ï¼‰ã€?

现在考虑下面˜q™ç§æƒ…况åQŒæœ‰ä¸€ä¸ªçˆ¶¾c»BaseåQ? 

public class Base {

            

            public void foo() throws ExceptionA {

            

            // ...

            

            }

            

            }

现在需要ç‘ô承Base˜q™ä¸ª¾cÕdƈ重蝲foo˜q™ä¸ªæ–ÒŽ³•åQŒåœ¨æ–°çš„实现中，foo可能抛出ExceptionBåQ? 

public class Extend extends Base {

            

            public void foo() throws ExceptionB {

            

            // ...

            

            }

            

            }

然而，˜q™æ ·å†™åœ¨Java里面是不合法的，因äØ“Java把可能会抛出的Exception看作函数特征的一部分åQŒå­¾cÕd£°æ˜ŽæŠ›å‡ºçš„Exception必须是父¾cȝš„子集ã€?

可以在Base¾cȝš„fooæ–ÒŽ³•ä¸­åŠ å…¥æŠ›å‡ºExceptionB的声明，然而，˜q™æ ·ž®Þq ´åäº†open-close原则。而且åQŒæœ‰æ—¶æˆ‘们没有办法去修改父类åQŒæ¯”如当重蝲一个Jdk里的¾cȝš„时候ã€?

另一个可能的做法是在Extendçš„fooæ–ÒŽ³•ä¸­catch住ExceptionBåQŒç„¶åŽæž„造一个ExceptionAòq¶æŠ›å‡ºã€‚这是个可行的办法但也只是一个权宜之计ã€?

如果使用RuntimeExceptionåQŒè¿™äº›é—®é¢˜éƒ½ä¸ä¼šå­˜åœ¨ã€‚这说明 checked Exceptionòq¶ä¸æ˜¯ä¸€ä¸ªå¾ˆå®žç”¨çš„概念，也意味着在程序设计的时候，我们应该让自å·Þqš„Exception¾cȝ‘ô承RuntimeException而不 是Exception。（˜q™å’ŒJDK的徏议正好相反，但实践证明这样做代码的质量更好。）

对于那些需要处理checked Exception的代码，可以利用一个ExceptionAdapter的类把checked Exception包装成一个RuntimeException抛出。ExceptionAdapter来自Bruce Eckelçš„Does Java need Checked Exception˜q™ç¯‡æ–‡ç« åQŒåœ¨˜q™é‡Œçš„ExceptionAdapter是我æ ÒŽ®JDK 1.4修改˜q‡çš„åQ? 

public class ExceptionAdapter extends RuntimeException {

            

            

            

            public ExceptionAdapter(Exception ex) {

            

            

            

            super(ex); 

            

            }

            

            

            

            public void printStackTrace(java.io.PrintStream s) { 

            

            

            

            getCause().printStackTrace(s); 

            

            }

            

            

            

            public void printStackTrace(java.io.PrintWriter s) { 

            

            

            

            getCause().printStackTrace(s); 

            

            

            

            }

            

            

            

            // rethrow()的作用是把被包装的Exception再次抛出�br />
            

            

            

            public void rethrow() 

            

            throws Exception

            

            {

            

            throw (Exception) getCause(); 

            

            }

            

            

            

            }

åQˆè´£ä»È¼–辑：¾~–辑龚勋åQ?



]]> Ö÷Õ¾Ö©Öë³ØÄ£°å£º Äþ¶¼ÏØ| ß®ÑôÏØ| ÒÊÔ´ÏØ| ÑÓ³¤ÏØ| ³²ºþÊÐ| ÐÂÄþÏØ| ³¤×ÓÏØ| ɽÑôÏØ| ÕÑËÕÏØ| ÃÜÔÆÏØ| ÎäÒÄɽÊÐ| ÐÂÁúÏØ| ÂÛ̳| ÏãºÓÏØ| ®½­ÏØ| ÄϳÇÏØ| ÁÉÔ´ÊÐ| ÒËÐËÊÐ| ÒÁÎáÏØ| ²¼¶û½òÏØ| ±¦¼¦ÊÐ| Çå·áÏØ| ÎèÑôÏØ| ÏìË®ÏØ| ÑÎɽÏØ| ᯹®ÏØ| Ö¦½­ÊÐ| Íû½­ÏØ| ·î½ÚÏØ| »á²ýÏØ| ÁùÖ¦ÌØÇø| ÔƺÍÏØ| ƽÌÁÏØ| Þ»³ÇÊÐ| ÄϳÇÏØ| ºÓÔ´ÊÐ| Ë«ÇÅÇø| ÆÁ¶«ÏØ| ³Â°Í¶û»¢Æì| ¶ÁÊé| Íû½­ÏØ|