97久久精品视频,免费在线观看成人,日本中文字幕视频一区

StringBuilder部分源码阅读

齐纳��多 — Wed, 29 Feb 2012 03:01:00 GMT

摘要: 1. StringBuilder extends AbstractStringBuilder implements CharSequence, Serializable (1)包含2个属�?>char[] value(底层数据�l�构是数�l?, int count(字符串长�? �q?个属性在AbstractStringBuilder定义 &nbs... 阅读全文

齐纳��多 2012-02-29 11:01 发表评论

转帖-String详解�?intern隐士

齐纳��多 — Mon, 27 Feb 2012 06:53:00 GMT

转帖地址�Q?a >http://congmo.github.com/blog/2012/02/16/1-translationofstring/(葱末)

规范化的字符串可节省�I�间�Q�代价就是花�Ҏ��多的CPU旉��来检��存储在RAM中的字符串和替换字符串副本。规范化之后的字�W�串�Q�不论存在多��引用，仅在RAM中存在一份。由于String是不可变的，所以比如两个不同的�Ҏ��y使用同一个字�W�串�Q�那么它们就可以使用同一个String的副本。不论字�W�串的意思在不同的语境下是否相同�Q�依旧可以共享，��好比sin可以是�h名，当然也是三角函数中的函数名。共享重复字�W�串的过�E�就叫做规范化。String.intern()�q�回规范化的��d��W�串的引用。规范化之后的字�W�串可以直接使用==(比较引用)来比较两个字�W�串是否相等。由于String不可变的�Ҏ��，可以节省很多�I�间。比�?#8221;pot”�?#8221;hippopotamus”中出玎ͼ�那么��׃��需要创建新的字�W�串�Q�额外分配新的空�?堆中的空�?�Q�返回一个相应指�?#8221;hippopotamus”的引用即可�?/p>

��Z��要规范化

规范化字�W�串有如下两个原因：

通过去除字符串字面值副本来节省�I�间(也就是字�W�串值在�Ҏ��Z��只有一份，其他全部是指向它的引�?�?/li>

使字�W�串比较变的很快。即使用equals比较规范化后的字�W�串也要快很多�?

��比如，

规范化与void字符�?/h3>
惌��避

规范化疑难杂�?/h3>
所有字�W�

规范化与String.substring()

bstring()�Ӟ��JVM只在栈中分配一个String�c�d��的引用，指向原始字符串的字面倹{��substring不需要额外分配空��_��也不需要拷贝字�W�。String.substring不会对结果进行规范化�?/p> 要还�?#8221;�z�d��”的子串指向原始字�W�串�Q�那么垃圑֛�收期��没法回收它�?/p> g产生的空串也不用自动规范化，因此�Q�空串也会导致长长的原始字符串没法被回收�?/p> class="highlight">

1 public static void main(String args[]){ class="lineno">2         String s = "a very long string"; class="lineno">3         // create an empty substring class="lineno">4         String e1 = s.substring( 0,0); class="lineno">5         // make sure the empty string is canonical class="lineno">6         String e2 = ( e1.length() ==0) ? "" :e1; class="lineno">7         System.out.println( e1=="" );// always prints false class="lineno">8         System.out.println( e2=="" );// always prints true    class="lineno">9 } 免�I�Z��致��原始字符串不能被回收�Q�就不要使用��M��void字符串指向原始字�W�串。void字符串有3中：””,” “,null�?/p> class="highlight"> 1 public final static String possiblyEmpty( StringpString) class="lineno"> 2 { class="lineno"> 3    if( pString==null) return""; class="lineno"> 4    pString=pString.trim(); class="lineno"> 5    if( pString.length() ==0) return""; class="lineno"> 6    returnpString; class="lineno"> 7 } class="lineno"> 8 public final staticStringpossiblyNull( StringpString) class="lineno"> 9 { class="lineno">10    if( pString==null) returnnull; class="lineno">11    pString=pString.trim(); class="lineno">12    if( pString.length() ==0) returnnull; class="lineno">13    returnpString; class="lineno">14 } class="lineno">15 public final staticStringneverNull( StringpString) class="lineno">16 { class="lineno">17    /* if pString is null, Java will throw an NullPointerException */ class="lineno">18    pString=pString.trim(); class="lineno">19    /* if pString is empty or blank, throw a NullPointerException */ class="lineno">20    if( pString.length() ==0) throw newNullPointerException(); class="lineno">21    returnpString; class="lineno">22 } 串在编译期间被规范化，那么�E�序�q�行时��生的字符串就不能被规范化。这��h��较恶心的一�Ҏ��在大多数情况下程序可以正常运行，但是在特�D�的情况下就会出错。就比如�Q����?=替代equals来比较两个字�W�串是否相等�Q�绝大多数是可行的，因�ؓ字符串会被规范化�Q�但是不排除特例�Q�比如运行期间��生的字符丌Ӏ?/p> _string_">规范化与new String( String ) s = new String( “hello” );代替String s = “hello”;
�q�与规范化正好相反，�q�样创徏了一个全新的”hello”字符�Ԍ��虽然有相同的字面��|��但是不会被规范化。在两种场景下适合使用new来创建字�W�串�Q?/p>
预得��C��个唯一的字�W�串同步对象�?/li>
��Z��不引用庞大的原始字符丌Ӏ���用new来创建字�W�串�Q�就可以使原始字�W�串被回收。如果只有几个很短的子串包含在一个庞大的字符串中�Q�这时��用new来创建新的字�W�串是值得的。当然如果有众多的子串都要指向一个母�Ԍ�����没有必要这样做了�?
使用new String( String )��׃��定会创徏一个全新的字符串吗�Q�答案是肯定的。你可能以�ؓJVM很智能，会将新创建的字符串规范化�Q�然后返回指向母串的引用。但是语�a�规范中指出，new String()一定会创徏一个全新的字符�Ԍ�����管JVM在理��Z��可以同String.substring(0)和String.intern.substring(0)一栯���行规范化�Q�防止出现多个拷贝�?/p>
�q�就引申出另外一个问题，s == s.substring(0)��L���q�回false吗？�{�案也是肯定的�?/p>
�q�有一个适合用new来创建字�W�串的地方，如下�Q?/p>
1 String password = new String( jpassword.getPassWord() );

getPassWord�Ҏ���q�回一个字�W�数�l?char)�Q�这么做�q�不愚蠢�Q�在高安全性的场景下，���可以将char数组清空�?/p>
看下�q�段代码�Q�String s = new String( “Hello” ); 当变量s所在的�c�被加蝲的时候，字面�?#8221;Hello”会被规范化，但是愚蠢的��用new String�Q�会在堆中重新创��Z��份字面�?#8221;Hello”�Q�地址与规范化后的”Hello”不同。在Sun的JVM中，规范化的字符串被存储在一个叫perm gen的特�D�RAM区域�Q�这个区域中JVM也加载类和存储本地编译后的代码，而且规范化后的字�W�串与存储在堆中的普通对象一栗���如果这样写�Q�String s = “Hello”�Q�就不会重新创徏”Hello”的副本，而是直接指向规范化后的字�W�串�?/p>
规范化与垃圾回收
在JDK的早��L��本中�Q�由于JVM要持有存储规范化后字�W�串的HashTable的引用，以便���查新创徏的字�W�串是否已在�׃�n池中存在�Q�这样就��D��了规范化后的字符串没法被垃圾回收器回收。随着1.2版本中引入了弱引用之后，无用的规范化字符串就可以被回收了�?/p>
JDK1.2版本之后�Q�规范化字符串在没用引用指向它时�Q�可以被回收�Q�而且规范化不是只发生在编译期。这样以�~�码的方式重新创建、规范化字符串时�Q�新创徏的字�W�串对象会变成唯一的原始字�W�串。这样做不会带来实际的问题，使用==来比较两个字�W�串包含的字�W�是否相�{�同样奏效�?�q�里理解的不是很好，我觉得应该是�q�样的：同一个字面��D��范化后，之前的那个字面值的地址会被新地址替换�?
溢出
java.lang.OutOfMemoryError: String intern table overflow 表示规范化字�W�串太多。一些低版本的JVM规定规范化字�W�串不能���过64K(大约50000�?。IBM的Java1.1.8 JRE���有�q�样的限制。它是Error�Q�不是Exception�Q�如果想捕获它，可以�q�样做：
 1 public class InternTest
 2 {
 3         public static final intn=80000;
 4         public static void main( String[] args)
 5         {
 6                 String[] hold = new String[n];
 7                 // build list of interned strings
 8                 for( inti=0;i<n;i++)
 9                 {
10                         try
11                         {
12                             hold[i] =Integer.toString(i).intern();
13                         }
14                         catch( Throwablee)
15                         {
16                             System.out.println( "intern exploded at " +i);
17                             System.exit( 1);
18                         }
19                  }
20                 // make sure they were really interned.
21                 for( inti=0;i<n;i++)
22                 {
23                 if( hold[i] !=Integer.toString(i).intern() )
24                 {
25                     System.out.println( "intern failed at " +i);
26                     System.exit( 1);
27                 }
28         }
29               System.out.println( "intern good for at least " +n+" Strings." );
30 }

依旧要注意规范化�?#8221;不利”垃圾回收�?/p>
底层
�q�里只讲底层规范化如何�v作用的最���单�Ş式。JVM内部在堆中存储对象，包括规范化与普通的String对象(�q�个说法貌似不是很严�?。而且规范化的String被放在一�?#8221;�?#8221;HashMap中�?/p>
HashMap中的String集合�Q�也叫字�W�串帔R��池。他们和堆中其他普通对象没什么两��P��只是因�ؓ�l�过优化后，生存期要长一些。String对象在堆中，而指向它的引用存在HashMap中，所以规范化字符串有自己的共享池�?/p>
当字�W�串被规范化�Ӟ��先在HashMap中检查是否已存在�Q�如果存在则�q�回指向��d���W�串的引用，通常�q�个引用优先自��n的引用，而自�w�的副本���很快被垃圾回收器回收。如果没有，则将其引用添加到HashMap中，�q�注册�ؓ��d���W�串。规范化的过�E�不会再生成字符串的副本�Q�只是持有主字符串的唯一引用�?/p>
规范化与非规范化的字�W�串都存储在堆中。由于规范化时��生的是弱引用�Q�所以当除了HashMap中的弱引用再无其他引用指向主字符串时�Q�该��d���W�串���可以被回收了�?/p>
new String�Ӟ��不会自动规范化，因此在堆中会有同一个字�W�串的多个副本。随后调用该字符串的intern�Ҏ���Q�这些副本也不会被清除�?/p>
我��L��觉这里貌似有问题�Q�干脆不���译了，把原文脓上吧�?/p>
This is a simplified version of how interning works under the hood. Inside the JVM is the heap where all allocated Objects reside. This includes Strings both interned and ordinary. (In Sun’s JVM, the interned Strings (which includes String literals) are stored in a special pool of RAM called the perm gen, where the JVM also loads classes and stores natively compiled code. However, the intered Strings behave no differently than had they been stored in the ordinary object heap.) In addition, interned Strings are registered in a weak HashMap.The collection of Strings registered in this HashMap is sometimes called the String pool. However, they are ordinary Objects and live on the heap just like any other (perhaps in an optimised way since interned Strings tend to be long lived). The String Object lives on the heap and a reference to it lives in the HashMap. There is so separate pool of interned String objects. Whenever a String is interned, it is looked up in the HashMap to see if it exists already. If so the user gets passed a reference to the master copy. Normally he will use that copy in preference to his. His duplicate copy then will likely soon have no references to it and will be eventually garbage collected. If the String has never been seen before, a reference to it will be added to the HashMap and intern will hand him a reference to his own String, now registered as the unique master. Note that the intern process does not make a copy of the String, it just keeps a reference to the unique master copies. All the Strings, interned and ordinary live on the heap. When there are no references left to a String except the intern HashMap registry reference, it will be garbage collected since intern keeps only a weak reference to it. When you say new String, it is not automatically interned. Thus there may then be duplicates on the heap. If you later use intern on that String, those duplicates won’t be cleaned up. Only when you intern all copies of a String, and discard references to the uninterned versions do you maintain but a single copy. 
手动规范�?/h3>
规范化最大的问题���是知道�E�序�l�束才能销毁占用RAM的空��_�����管再没有引用指向主字符�Ԍ��也不能被垃圾回收器回�?早期版本)。如果想使用一个��时的规范化字�W�串�Q�可以��用手动规范化�?/p>
然而，现在��L��的JVM中的规范化字�W�串�׃�n池都是采用弱引用实现的，所以只要没有强引用指向��d���W�串�Q�则可被垃圾回收器回收。你可以像JVM一��P��自己实现规范化的�q�程�?/p>
比如假设从文件中��d��以逗号分隔的�h名与地址�Q��ƈ以某�U�顺序存入集合，�׃��很多人居住在同一城市�Q�所以RAM中就会充满了同一个城市的副本�?/p>
那么创徏一个HashMap(不是HashSet),用于存储每个城市名称的主字符丌Ӏ�每�ơ获取城市时�Q�先从HashMap中查找，如果存在则用��d���W�串的引用替换自�w�的引用。自�w�String对象的副本很快就会被垃圾回收器回收。如果不存在增加城市到HashMap�?/p>
当读完城市后�Q�就可以讲HashMap抛弃�Q�而放入到HashMap中的��d���W�串�Q�除了没有其他引用指向的��d���W�串被垃圑֛�收器回收掉之外，�q�是一样存在，一��h��有唯一的引用，而且与规范化后的字符串一栗��?/p>
原文地址�Q?a >http://mindprod.com/jgloss/interned.html




�q�里���q�����译完了�Q�不�q�有些地方觉得怪怪的。还有由于个人水�q�_��在是有限�Q�难免有地方�_�糙。另外，如果你说研究�q�个实在是没有意思类似的话，那拜托你憋在心里吧，谢谢了�?/p>
因�ؓ在看jdk源码�Q�看到String中最后一行的intern是个native�Ҏ���Q�于是就到处查资料，�q�在OSChina上提��Z��个问题：http://www.oschina.net/question/129471_38493�Q�讨��Z�����提��C��撒加在javaeye上的一个帖子的回答�Q?a >http://www.iteye.com/topic/1112592�Q�于是我做了如下的测试，又画�?张图�?/p>
���试环境�Q?
java version "1.6.0_17" Java(TM) SE Runtime Environment (build 1.6.0_17-b04) Java HotSpot(TM) Client VM (build 14.3-b01, mixed mode, sharing) 
 
1 public static void main(String[] args) {
2         String str0 = "congmo.github.com";
3         System.out.println(str0.intern() == str0);
4 }

输出�l�果�Q�true 
1 public static void main(String[] args) {
2         String str0 = args[0];
3         System.out.println(str0.intern() == str0);
4 }

同样在命令行输入:congmo.github.com
输出�l�果�Q?br />false 
 1 public static void main(String[] args) {
 2 
 3         String str0 = "congmo.github.com";
 4         System.out.println(str0.intern() == str0);
 5                 
 6         String str1 = new String( args[0] );
 7         System.out.println(str1.intern() == str1);
 8 
 9         System.out.println(str0 == str1.intern());
10 }

输出�l�果�Q?br />true
false
true

从前面两�D�代码中可以看出�Q���用命令行的方式同栯���入参�?#8221;congmo.github.com”�Q�将args0赋值给str0�Q�然后str0.intern()==str0的结果竟然是false�Q�难道真如javaeye那篇帖子中有人怀疑的那样�Q�JVM���args0提前���p��范化了？按道理应该不会啊�?/p>
���试环境�Q?
java version "1.7.0_02" Java(TM) SE Runtime Environment (build 1.7.0_02-b13) Java HotSpot(TM) Client VM (build 22.0-b10, mixed mode, sharing) 
 
1 public static void main(String[] args) {
2         String str0 = args[0];
3         System.out.println(str0.intern() == str0);
4 }

输出�l�果�Q?true 
1 public static void main(String[] args) {
2         String str0 = new String( args[0] );
3         System.out.println(str0.intern() == str0);
4 }

输出�l�果�Q?true 
1 public static void main(String[] args) {
2         String str0 = args[0];
3         System.out.println(str0.intern() == str0);
4         String str = new String( args[0] );  
5         System.out.println(str.intern() == str);
6         System.out.println(str.intern() == str0);
7 }

输出�l�果�Q?br />true
false
true

但是�?.7版本执行的结果看来，貌似可以���定JVM没有对args0规范化，但是从javaeye帖子讨论中可以知�?.7版本后perm gen�q�个内存������q�掉了，所以规范化之后的字�W�串也存储在堆中�Q�所以无论args0有没有提前被规范化，str0始终都会指向堆中那个引用。按照我的理解，如下图所�C�：
 
所以现在看来还是个未知数�?/p>
另外�Q�我按照自己的理解针�?中情�는��?张图�Q�都是用于说明JVM的内存分配的�?注：jdk1.6或之前版本，1.7之后�Ҏ�������砍掉�?/p>
 
 
�q�两张图都是描述使用new创徏String�Q�然后再调用自��n的intern�Ҏ��后内存以及引用的变化�?/p>
 

齐纳���多 2012-02-27 14:53 发表评论



转帖-String详解一:基础
齐纳���多 — Mon, 27 Feb 2012 06:49:00 GMT
转帖地址�Q?a >http://congmo.github.com/blog/2012/02/16/1-translationofstring/(葱末)


译者注�Q�翻译这���文章是有目的性的�Q�不是闲来无事打发时间。刚刚看完String的源码，虽然看完�Q�但是有很多东西(或者说”陷阱”)在源码中得不��C��现。可能是在编译器中进行了优化。无意中发现了这���文章，里面讲述了一些隐含的�Q�源码中比较隐晦或者看不到的东�ѝ��比如substring,intern�{�。所以才有了���译�?#8221;动机”�Q�还有一���专门讲�q�intern的，���在之二中翻译。另�Q�翻译纯属个�����为，因技术与��p��水准有限�Q�文中肯定不乏欠妥之处，如果你能文明的指出，在下���感�Ȁ不尽。如�a�辞中满是不尊重，则请收回。希望能带给其大家帮助，以达共同�q�步之目的�?/p>
Java中的字符串不同于与C++中的字符�Ԍ��不能改动字符串中的字�W�。预查找字符串中某个字符�Q�可是��用charAt()�Ҏ��。Java中的字符串都�?6位的Unicode。可是��用StringBuffer或者char修改字符丌Ӏ�从1.5版本之后�Q�可以��用StringBuilder替代StringBuffer�Q�StringBuilder速度更快�Q�但是是�U�程不安全的�?/p>
String.length()用来获取字符串的长度�Q�而不是像其他�c�M��使用的length或size()�?/p>
�I�字�W�串
Java中有3�U�空字符�Ԍ��null,”“�?#8221; “。下面就是如何区别这3中空字符串的�Ҏ���?/p>
1 if( s==null) echo( "was null" );
2 else if( s.length() ==0) echo( "was empty" );
3 else if( s.trim().length() ==0) echo( "was blank or other whitespace" );

字符串比�?/h3>
1 if( "abc".equals(s) ) echo( "matched" );

�?/p>
1 if( s.equals( "abc" ) ) echo( "matched" );

当s为null�Ӟ��不会抛出异常�Q�只会当作它们不相等�?除非使用String.intern()对字�W�串�q�行合�ƈ(interned)�Q�否则不可以使用==来判断两个字�W�串是否相等。要使用equals()�Ҏ��来比较�?/p>
如果一不小心误�?=来比较字�W�串�Q�编译器也不会发�����告。不�q�的是，�q�个bug直到�~�译器或者虚拟机昑ּ��q�行规范�?interning)�Ӟ��才会凸显出。规范化(interning)之后�Q�会获得一个字�W�串的原始引用。这样其他字�W�串的副本就可以很快被垃圑֛�收器回收。然而，规范�?interning)�?点不���I��
要花贚w��外的旉���在一个HashTable中查扑֎�始字�W�串�?/li>
在某些JVM的实��C���Q�有规范化字�W�串最大长度�ؓ64K的限制�?/li>
在某些JVM的实��C���Q�规范化后的字符�Ԍ�����q��不在被引用，也永�q�不会被垃圾回收器回收�?/li>
如果��x��较两个字�W�串的大���，��׃��能��用常规的比较操作了，可以使用compareTo()或compareToIgnoreCase()�Ҏ��替代�?/p>
1 String s ="apple";
2 String t ="orange";
3 if( s.compareTo(t) <0)
4 {
5    System.out.println( "s < t" );
6 }

compareTo的返回��|��
如果s在字�W�表中排在t之后�Q�返回正数�?/li>
如果s与t位置一��P���q�回0.
如果s在字�W�表中排在t之前�Q�返回负数�?/li>
�q�个时候可以粗略的把字�W�串当作数字。返回值就是s-t�?/p>
新手可能会因��Z��面的几个�l�果感到惊奇�Q?/p>
"abc".compareTo( "ABC") returns "abc" > "ABC" compareTo是大���写敏感的�?/li>
"abc ".compareTo ( "abc") returns "abc " > "abc" �I�格与其他字�W�一栗��?/li>
"".compareTo( null) 会抛出：java.lang.NullPointerException 异常�?/li>
""与null不同。多数String中的�Ҏ��可以很好的处�?"�Q�但是很���能接受null的�?/li>
字符串的比较是通过Unicode数字字符的比较来实现的。不能根据本地语�a��q�行调整�?/li>
当实现自��q���c�L���Q�默认的Object.equals不会一个个字段�q�行比较。需要自行实现equals来比较。默认equals只是比较两个引用是否指向同一个对象�?/p>
大小写敏感与大小写不敏感比较
 1 // String comparison, case-sensitive and insensitive.
 2 Stringapple="apple";
 3 Stringorange="orange";
 4 
 5 // case-sensitive compare for equality, faster than order comparison.
 6 booleansame=apple.equals( orange);
 7 
 8 // case-insensitive compare for equality, slower that case-sensitive comparison.
 9 booleansame=apple.equalsIgnoreCase( orange);
10 
11 // case-sensitive compare for order.
12 // +ve if apple>orange, 0 if apple==orange, -ve if apple<orange
13 intorder=apple.compareTo( orange);
14 
15 // case-insensitive compare for order.
16 // +ve if apple>orange, 0 if apple==orange, -ve if apple<orange
17 intorder=apple.compareToIgnoreCase( orange);
18 
19 // If you are going compare the same strings over and over,
20 // and you want to compare them in a case-insensitive way, it may pay
21 // to convert them to lower case, and use the faster case-sensive compare.
22 StringlcApple=apple.toLowerCase();
23 StringlcOrange=orange.toLowerCase();
24 
25 // effectively a case-insensitive compare for equality,
26 booleansame=lcApple.equals( lcOrange);
27 
28 // effectively a case-insensitive compare for order.
29 // +ve if apple>orange, 0 if apple==orange, -ve if apple<orange
30 intorder=lcApple.compareTo( lcOrange);

字符串搜�?/h3>
字符串搜索可使用indexOf和lastIndexOf。他们都可以通过fromOffset改变搜烦开始的位置。返回的�l�果是相对于字符串开始的位置(0)�Q�而不是相对于fromOffset的位�|�。如果搜索时忽略大小写，可先���字�W�串全部转换成大写或���写。可以这样实玎ͼ�
 1     public static voidmain( String[] args)
 2         {
 3         // use of indexOf
 4         finalStrings1="ABCDEFGABCDEFG";
 5         out.println( s1.indexOf( "CD" ) );
 6         // prints 2, 0-based offset of first CD where found.
 7 
 8         out.println( s1.indexOf( "cd" ) );
 9         // prints -1, means not found, search is case sensitive
10 
11         out.println( s1.toLowerCase().indexOf( "cd" ) );
12         // prints 2,  0-based offset of first cd where found
13 
14         out.println( s1.indexOf( "cd".toUpperCase() ) );
15         // prints 2,  0-based offset of first cd where found
16 
17         out.println( s1.indexOf( "CD",4/* start looking here, after the first CD */) );
18         // prints 9, 0-based offset relative to the original string,
19         // not relative to the start of the substring
20 
21         // use of last indexOf
22 
23         out.println( s1.lastIndexOf( "CD" ) );
24         // prints 9, 0-based offset of where last CD found.
25 
26         out.println( s1.lastIndexOf( "cd" ) );
27         // prints -1, means not found, search is case sensitive
28 
29         out.println( s1.toLowerCase().lastIndexOf( "cd" ) );
30         // prints 9,  0-based offset of where last cd found
31 
32         out.println( s1.lastIndexOf( "cd".toUpperCase() ) );
33         // prints 9,  0-based offset of where last cd found
34 
35         out.println( s1.lastIndexOf( "CD",8/* start looking here, prior to last */) );
36         // prints 2, 0-based offset relative to the original string,
37         // not relative to the start of the substring
38 
39         out.println( "\u00df" );
40         // prints German esset ligature sz single ss bate-like glyph
41 
42         out.println( "\u00df".toUpperCase() );
43         // prints SS, not SZ, two chars long!
44         }
45     }

查找单个字符有很多方法，其中不乏速度比一个一个字�W�比较是否相�{�快。理��x��况下�Q�编译器���_�������的将indexOf�Ҏ��单个字符参数转化为char�Q�那么可以将x.indexOf(y) >= 0 ���化�ؓx.contains(y)�?/p>
创徏字符�?/h3>
字符串是不可变的�Q�因此字�W�串不仅可以被无限期重用�Q�而且�q�可在很多场景下�׃�n。当你将一个字�W�串变量赋给另外一个字�W�串变量�Ӟ��不会再次产生副本。甚臛_��调用substring后，赋给了新的变量，也不会创建新的字�W�串。只有在一下几�U�情况下才会创徏新的字符�Ԍ��
字符串拼�?/li>
从文件中��d��字符�?/li>
愚蠢的��用new String(somethingElse)。一�U�情况下使用�q�种方式是恰当的�Q�参见substring()
使用StringBuffer/StringBuilder的toString或substring�Ҏ��
toString�Ҏ��
每种对象都可以调用toString�Ҏ�����自�w�的内容转化成�h�c�d���ȝ��形式。通常�Q�编写自定义�c�L���Q�尽���仅仅是��Z��degub�Q�也要单独实现toString�Ҏ���?/p>
�q�样来调用：String toShow = myThing.toString();
默认的Object.toString()很不������Q�它不会像你期待的那��P�����类中所有字�D���D��出。要辑ֈ��q�种预期�Q�就要自��q��码实现。默认的toString�Ҏ��会比较对象的hashCode或者对象的地址�?/p>
toString�Ҏ��有个���奇的地斏V��在需要�{换�ؓ字符串时�Q�好像自动调用toString�q�行了�{换�?/p>
一�U�情冉|��使用�Q�System.out.println(and brothers)�Q�其实它一点儿都不高深�Q�println只是使用众多的重载方法实现的。println有很多重载方法，每个基本数据�c�d��一个。每个基本数据类型的toString�Ҏ�����本�w��{化�ؓ字符丌Ӏ�但是我们知道基本数据类型中是没有toString�Ҏ��的啊�Q�确实是�q�样�Q�但是别忘记�Q�有些静态�{换方法，比如String.valueOf(double)���可以将双精度��Q�Ҏ��转化为字�W�串。对于�Q何String之外的对象，println�Ҏ��调用的是对象自��n重写后的toString�Ҏ���Q�再���结果传�l�参数只能�ؓString的println�Ҏ���?/li>
当��用字�W�串�q�接�W�时(+)�Q�toString���实被调用了。如果将两个对象相加�Q�Java���假定你���是惛_��他们�q�接�Q�于是调用各自的toString�Ҏ���Q�将�q�接后的字符串返回。在字符串与基本数据�c�d��相加的情况下�Q�依然奏效。连接符会先把基本数据类型�{换�ؓ字符�Ԍ��然后���结果连接�?/li>
字符串替�?/h3>
String.replace( char target, char replacement )、String. replace( String target, String replacement ) 两个�Ҏ��都是替换目标字符串中出现的所有指定的字符或字�W�串�Q�但是前者要比后者快很多。所以在替换单个字符�Ӟ��要��用前者，即��用单引号。不�q�的是，后者只有在1.5及其之后的版本中才可以��用�?/p>
replaceAll( String regex, String replacement ) �Ҏ��也是全部替换�Q�区别在于replaceAll�Ҏ��使用正则表达式搜索。欲使用replace( String target, String replacement ) 时千万不能��用replaceAll(String regex, String replacement) 。第二个参数不是���单的字符�Ԍ��String. replaceAll 与Matcher. replaceAll 一栗��?代表匚w��字符串的引用�Q�\则是正则表达式中的关键字�Q�所以需要将\转义为\\\\�Q�将$转义为\\$�?/p>
replaceFirst( String regex, String replacement ) 也��用正则表辑ּ��?/p>
Javadoc中String.replace是以 CharSequence为入参的�Q�别担心�Q�String实现�?CharSequence接口�Q�所以replace可以在String或StringBuilder中正�怋�用�?/p>
正则表达�?/h3>
String中包含很多非常好用的正则表达式方法，比如split、matches、replaceAll�q�有replaceFirst。通常情况下推荐��用高效的java.util.regex中的�Ҏ���Q�方法中的Pattern被提前编译，�q�且可重用。在不考虑效率的情况下�Q�就可以使用String中的正则表达式方法了�?/p>
replaceAll和replace都以低效的方式实玎ͼ�每次调用都要重新�~�译regex pattern�?/p>
1 // how replace is implemented.
2 // It uses regex techniques even though neither parameter is a regex.
3 publicStringreplace(CharSequencetarget,CharSequencereplacement)
4 {
5    returnPattern.compile( target.toString(),Pattern.LITERAL)
6    .matcher( this).replaceAll( Matcher.quoteReplacement( replacement.toString() ) );
7 }

所以，如果不止一�ơ调用replace或replaceAll�Ӟ��最好��用单独的正则表达式，�~�译一�ơ即可重用�?/p>
substring
substring很智能，与其他编�E�语�a�的深拯���不同�Q�它只是创徏一个指向原始不可变字符串的引用。比如根据substring参数讄���char的偏�U�d��|��与count属性值后�Q�返回一个指向它的引用，而不是全部拷贝。这样就�l�调试增��M��困惑�Q�因为每�ơ看到的都是整个字符串而不是截取后的子丌Ӏ�这样做有一个致命的�~�点�Q�就是子串一直保持着整个原始字符串的引用�Q�这样即使原始字�W�串已经没用了，也不能被垃圾回收器回收�?事实上String对象的引用可以被回收�Q�但是RAM中的char没法被回�?
所以查扑֭��W�串�Ӟ��使用indexOf(lookFor, offset)要好于先使用substring创徏子串再��用indexOf(lookFor)�?/p>
如果���切的知晓小子串会指向RAM中原始大字符串的char�Q���其不能被回收�Q�这个时候可以��用littleString = new String(littleString)来创��Z��个与原始字符串无关的新字�W�串来避免这�U�情�늚�发生�?/p>
如果你是通过src.zip来学习String.substring()�Q�那么这�U?#8221;陷阱”���很难被发现。因为它是用�q�String的一个非公有构造方法String (int offset, int count, char value) 来调整value的偏�U�d��和count值来实现�?/p>
原文链接�Q?a >http://mindprod.com/jgloss/string.html
                 http://mindprod.com/jgloss/substring.html


齐纳���多 2012-02-27 14:49 发表评论


Jvm查看工具
齐纳���多 — Mon, 27 Feb 2012 03:48:00 GMT
1.jps �c�M��于ps 可以查看java的进�E?br />2.jstat jvm垃圾攉���内存使用情况

S0:Survior1区内存占�?br />S1:Survior2区内存占�?br />E:Eden(新生�?Eden)
O:Old(老年�?
P:持久�?br />YGC:新生代gc�ơ数(minor gc)
YGCT�Q�gc旉���
FGC�Q�full  gc �ơ数
FGCT:full  gc旉���
GCT: 总gc旉��� 
3.gc日志输出
  -XX:+PrintGC                   gc概要信息
  -XX:+PrintGCDetails          gc详细信息
  -XX:+PrintGCTimeStamps    GC停顿耗时
  -XX:+PrintGCApplicationStopedTime  用户�q�程停顿旉���(stop the world)
  再加�?Xloggc:文�g路径   gc信息���会输出到指定的文�g�?br />4.jconsole可以�q�程或者本地监控jvm内存信息�Q�线�E�信�? �c�d��载信�?MBean信息

 5.jmap
 6.jhat
 7.jvisualVm
 8.eclipse memory analysis


齐纳���多 2012-02-27 11:48 发表评论


发扑克牌的简�?java)实现
齐纳���多 — Wed, 22 Feb 2012 01:28:00 GMT

package cn.com.pbqi.corejava;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;

public class CardGame {
    
    private int pNum;
    private List<String> cardList = new ArrayList<String>(54);
    private Map<String,List<String>> map = new TreeMap<String,List<String>>();
    
    /** *//**
     * 打牌的�h�?最��?个�h,最�?个�h
     * @param pNum
     */
    public CardGame(int pNum) {
        if(pNum < 2 || pNum > 4) {
            throw new IllegalArgumentException("CardPlayer must between 2 and 4, CardPlayer=" + pNum);
        }
        this.pNum = pNum;
        for(int i = 0; i <pNum; i++) {
            map.put(i+"-", new ArrayList<String>());
        }
        
        this.initCards();
        
        this.distribute();
        
        this.display();
    }
    
    /** *//**
     * 初始化一副扑�?br />     */
    public List<String>  initCards() {
        String[] type = {"r","b","s","m"};
        String[] cards = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String[] kings = {"大王","���王"};
        
        for(int i = 0; i < type.length; i++) {
            for(int j = 0; j < cards.length;j++) {
                cardList.add(cards[j]+type[i]);
            }
        }
        for(int k = 0; k < kings.length; k++){
            cardList.add(kings[k]);
        }
        return cardList;
    }
    /** *//**
     * 发牌
     */
    public void distribute() {
        Random r = new Random();
        int len = cardList.size();
        int bakLen = len;
        for(int i = 0; i < len; i++) {
            int rNum = r.nextInt(bakLen);
            String card = cardList.get(rNum);
            int left = i % pNum;
            map.get(left+"-").add(card);
            cardList.remove(rNum);
            bakLen--;
        }
    }
    
    public void display() {
        System.out.println("======r:�U�桃,b:黑桃,s:方块,m:�c����===========");
        for(Iterator<String> iter = map.keySet().iterator(); iter.hasNext();) {
            String key = iter.next();
            List<String> list = map.get(key);
            System.out.print(key+ " 的牌�?==");
            for(int i = 0; i < list.size();i++) {
                System.out.print(list.get(i));
                if(i != list.size() -1) {
                    System.out.print(",");
                }
            }
            System.out.println("");
        }
    }
    
    public static void main(String[] args) {
        CardGame cg = new CardGame(4);

    }

}
 

齐纳���多 2012-02-22 09:28 发表评论


求一个字�W�串是否是回文数
齐纳���多 — Tue, 16 Dec 2008 01:40:00 GMT
 
/** *//**

 * 判断一个字�W�串是否是回文数

 *

 * @author Qinaldo

 *

 */

public class PalindromeNum {



    public static void main(String[] args) {

        

        while(true) {

            

            System.out.println("误���入一个字�W�串�Q?/span>");

            Scanner scan = new Scanner(System.in);

            String str = scan.next();

            

            int len = str.length();

            int i;

            

            if("bye".equals(str)) {

                break;

            }

            

            for(i=0; i<len/2; i++) {

                if(str.charAt(i) != (str.charAt(len-i-1))) {

                    break;

                } 

            }

            

            if(i >= len/2) {

                System.out.println(str + ",是回文数�Q?/span>");

            } else {

                System.out.println(str + ",不是回文敎ͼ�");

            }

        }

    }

}
  

齐纳���多 2008-12-16 09:40 发表评论


齐纳���多 — Thu, 04 Dec 2008 07:32:00 GMT
package com.qpb.ant;
import java.util.ArrayList;

import java.util.List;

import java.util.Random;
public class TestRandom {

 

 public final static int TOTAL = 33;

 public final static int NUMBER = 7;

 

 public static void main(String[] args) {

      List list = new ArrayList();

      StringBuffer sb = new StringBuffer();

      Random r = new Random();

  

      for(int i = 0; i < TOTAL; i++) {

           list.add(i + 1 + "");

      }

  

      for(int j = 0; j < NUMBER; j++) {

           int size = list.size();

           String s = list.get(r.nextInt(size));

           sb.append(s);

           if(j != NUMBER -1) {

                sb.append(",");

           }

           list.remove(s);

      }

          System.out.println(sb.toString());

     }
}
     

齐纳���多 2008-12-04 15:32 发表评论

97久久精品视频,免费在线观看成人,日本中文字幕视频一区

StringBuilder部分源码阅读

转帖-String详解�?intern隐士

��Z��要规范化

规范化与void字符�?/h3> 惌���避

规范化疑难杂�?/h3> 所有字�W�

规范化与String.substring()

规范化与垃圾回收

溢出

底层

转帖-String详解一:基础

�I�字�W�串

大小写敏感与大小写不敏感比较

toString�Ҏ��

substring

Jvm查看工具

发扑克牌的简�?java)实现

求一个字�W�串是否是回文数

规范化与void字符�?/h3>
惌��避

规范化疑难杂�?/h3>
所有字�W�