<rt id="bn8ez"></rt>
<label id="bn8ez"></label>

  • <span id="bn8ez"></span>

    <label id="bn8ez"><meter id="bn8ez"></meter></label>

    鷹翔宇空

    學習和生活

    BlogJava 首頁 新隨筆 聯系 聚合 管理
      110 Posts :: 141 Stories :: 315 Comments :: 1 Trackbacks
    引自:http://www.mengyan.org/blog/archives/2004/08/14/87.html

    These days, when I’m reading some other guy’s code, I encounter some problem. In these code, I can read following codes:

    1. JButton?button?= new?JButton("OK");
    2. button.setActionCommand("OK");
    3. button.addActionListener(this);
    4. ......
    5. actionPerformed(e)?{
    6. ? ? String?s?= e.getActionCommand();
    7. ? ? if(s=="OK")
    8. ? ? ......
    9. }

    Look, it use “==” but not “equals” here. “Oh, it must be a bug!”, I told myself. But, wait, when I excuted the program, it worked quite well. And till this moment, I remembered, current powerful JVM will maintain a constant pool for String, so maybe two “OK” will reference the same place. So, such mechanism will work.

    But, does Java Language Specification has such standard? and all JVM will follow this standard? I continue to dig into it.

    First, I found such item in JLS 3.10.5 — String literals.

    Abstract some points here:

    Literal strings within the same class ($8) in the same package ($7) represent references to the same String object ($4.3.1).
    Literal strings within different classes in the same package represent references to the same String object.
    Literal strings within different classes in different packages likewise represent references to the same String object.
    Strings computed by constant expressions ($15.28) are computed at compile time and then treated as if they were literals.
    Strings computed at run time are newly created and therefore distinct.
    The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

    So, this is the feature of String class, every JVM should follow. And, when I read the code of String.java, I found such comments in method “intern“.

    public String intern()
    Returns a canonical representation for the string object.
    A pool of strings, initially empty, is maintained privately by the class String.
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~So good:-)

    When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.
    It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.
    All literal strings and string-valued constant expressions are interned. String literals are defined in $3.10.5 of the Java Language Specification.

    It’s quite clear about the case I encountered. Then I understand, this is not a bug, but the trick :P . But, why he use “==” but not “equals“, I think that will be more clear and more easy to read, I think there must be other guys to be puzzled as me :-) .

    I think the author must care more about the performance than the code, the performance of “==” sure if better than “equals“, especially when the String is long~.

    Ok, everything clear now, and sure, not only String has such pool. For example:

    1. Integer?i?= 1;
    2. Integer?j?= 1;

    what will System.out.println(i==l) output? I think you can get the right answer. :P

    Update (2005.11.09):

    "String"’s method "equalsIgnoreCase" also take advantage of this string pool:

    1. public?boolean?equalsIgnoreCase(String?anotherString)?{
    2. ? ? return?(this?== anotherString)?? true?:
    3. ? ? ? ? ? ?(anotherString?!= null)?&& (anotherString.count?== count)?&&
    4. ? ? regionMatches(true, 0, anotherString, 0, count);
    5. }

    If the two string point the same one, simply return true.

    So, if you need to compare Strings frequently, you should "Intern" them.

    For example, in Lucene’s source code, you need to compare the Field name very often, so, they intern the field name.

    1. this.name?= name.intern();? ? ? ? ? ? ? // field names are interned

    Popularity: 9%

    posted on 2006-09-13 17:45 TrampEagle 閱讀(827) 評論(0)  編輯  收藏 所屬分類: java
    主站蜘蛛池模板: 日本亚洲免费无线码| 亚洲激情中文字幕| 亚洲av色香蕉一区二区三区| 无码国产精品一区二区免费式直播| 亚洲AV无码久久精品狠狠爱浪潮| 国产中文字幕在线免费观看| 亚洲精品乱码久久久久久| 中国一级特黄高清免费的大片中国一级黄色片| 免费在线不卡视频| EEUSS影院WWW在线观看免费| 精品国产亚洲男女在线线电影| 青青操免费在线观看| 亚洲∧v久久久无码精品| 精品无码人妻一区二区免费蜜桃| 亚洲综合激情另类小说区| 国产美女在线精品免费观看| 亚洲av无码专区在线观看下载| 国产成人在线免费观看| 精品国产呦系列在线观看免费| 亚洲成AV人片一区二区密柚| 51视频精品全部免费最新| 亚洲色偷偷色噜噜狠狠99| 国产99视频精品免费视频7| 精品国产呦系列在线观看免费| 亚洲成a人片在线观看无码| 91短视频免费在线观看| 亚洲成a人片在线不卡一二三区| 亚洲国产精品无码久久青草| 在线观看免费播放av片| 亚洲一区二区三区亚瑟| 免费一级毛片不卡在线播放| 久久aⅴ免费观看| 亚洲人成综合网站7777香蕉| 亚洲成av人片一区二区三区| 一个人免费视频在线观看www| 亚洲一级毛片免费在线观看| 亚洲精品久久久www | kk4kk免费视频毛片| 亚洲人成网站在线播放影院在线 | 国产91在线|亚洲| 亚洲AV日韩精品一区二区三区 |