ž®Þq¼–码来说各有好处：for更灵‹z»ï¼Œforeach更简ä¾?br />

forå’Œforeach都是java中重要的集合遍历æ–ÒŽ³• 
for循环�你可以选择从前往后遍历，也可以从后往前遍历，也可以不遍历默写�
但是foreach只能从前往后遍历，而且每一个都会遍历一‹Æ¡ï¼Œä»–们之间的选择得看你项目程序中的需求而定

JVM在解释执行行åQŒéƒ½ä¼šå°†for与foreach解释成iteratorã€?/pre>

æ€È»“如下åQ?/p>
1.如果只是遍历集合或者数¾l„，用foreach好些åQŒå¿«äº›ã€?/p>
2.如果寚w›†åˆä¸­çš„å€ÆD¿›è¡Œä¿®æ”¹ï¼Œž®Þp¦ç”¨for循环了ã€?br />其实foreach的内部原理其实也是Iterator,但它不能像Iterator一样可以äh为的控制åQŒè€Œä¸”也不能调用iterator.remove()åQ?br />更不能ä‹É用下标来讉K—®æ¯ä¸ªå…ƒç´ åQŒæ‰€ä»¥ä¸èƒ½ç”¨äºŽå¢žåŠ ï¼Œåˆ é™¤½{‰å¤æ‚的操作ã€?/p>

如果有些代码必须在项目启动的时候就执行,ž®±éœ€è¦ä‹É用静态代码块,˜q™ç§ä»£ç æ˜¯ä¸»åŠ¨æ‰§è¡Œçš„;需要在™å¹ç›®å¯åŠ¨çš„时候就初始化但是不执行,在不创徏对象的情况下,可以供其他程序调ç”?而在调用的时候才执行åQŒè¿™éœ€è¦ä‹É用静态方æ³?˜q™ç§ä»£ç æ˜¯è¢«åŠ¨æ‰§è¡Œçš„. 静态方法在¾cÕdŠ è½½çš„æ—¶å€?ž®±å·²¾låŠ è½?可以用类名直接调用ã€?/p>

静态代码块和静态方法的区别是：

静态代码块是自动执行的;

静态方法是被调用的时候才执行�

静态方法：如果我们在程序编写的时候需要一个不实例化对象就可以调用的方法，我们ž®±å¯ä»¥ä‹É用静态方法，具体实现是在æ–ÒŽ³•å‰é¢åŠ ä¸ŠstaticåQŒå¦‚下：

public static void method(){}

在ä‹É用静态方法的时候需要注意一下几个方面：

在静态方法里只能直接调用同类中其他的静态成员（包括变量和方法）åQŒè€Œä¸èƒ½ç›´æŽ¥è®¿é—®ç±»ä¸­çš„非静态成员。这是因为，对于非静态的æ–ÒŽ³•å’Œå˜é‡ï¼Œéœ€è¦å…ˆåˆ›å¾¾cȝš„实例对象后才可ä‹É用，而静态方法在使用前不用创å»ÞZ“Q何对象。（备注åQšé™æ€å˜é‡æ˜¯å±žäºŽæ•´ä¸ª¾cȝš„变量而不是属于某个对象的åQ?/p>

静态方法不能以ä»ÖM½•æ–¹å¼å¼•ç”¨thiså’Œsuper关键字，因äؓ静态方法在使用前不用创å»ÞZ“Q何实例对象，当静态方法调用时åQŒthis所引用的对象根本没有äñ”生ã€?/p>

静态程序块åQšå½“一个类需要在被蝲入时ž®±æ‰§è¡Œä¸€ŒD늨‹åºï¼Œ˜q™æ ·å¯ä»¥ä½¿ç”¨é™æ€ç¨‹åºå—ã€?/p>

public class DemoClass {

private DemoClass(){}

public static DemoClass _instance;

static{

if(null == _instance ){

_instance = new DemoClass();

}

}

public static DemoClass getInstance(){

return _instance;

}

}

˜q™æ ·çš„程序在¾c»è¢«åŠ è²çš„时候就执行了static中的代码ã€?/p>

Ps:java中类的装载步骤：

在Java中，¾c»è£…载器把一个类装入Java虚拟æœÞZ¸­åQŒè¦¾lè¿‡ä¸‰ä¸ªæ­¥éª¤æ¥å®Œæˆï¼šè£…蝲、链接和初始化，其中链接又可以分成校验、准备和解析三步åQŒé™¤äº†è§£æžå¤–åQŒå…¶å®ƒæ­¥éª¤æ˜¯ä¸¥æ ¼æŒ‰ç…§™åºåºå®Œæˆçš„，各个步骤的主要工作如下：

所谓装载就是寻找一个类或是一个接口的二进制åŞ式åƈ用该二进制åŞ式来构造代表这个类或是˜q™ä¸ªæŽ¥å£çš„class对象的过½E‹ã€‚其中类或接口的名称是给定了的ã€?/p>

装蝲åQšæŸ¥æ‰‘Ö’Œå¯¼å…¥¾cÀLˆ–接口的二˜q›åˆ¶æ•°æ®åQ?/p>

链接åQšæ‰§è¡Œä¸‹é¢çš„校验、准备和解析步骤åQŒå…¶ä¸­è§£æžæ­¥éª¤æ˜¯å¯ä»¥é€‰æ‹©çš„ï¼›

校验åQšæ£€æŸ¥å¯¼å…¥ç±»æˆ–接口的二进制数据的正确性；

准备åQšç»™¾cȝš„静态变量分配åƈ初始化存储空é—ß_¼›

解析åQšå°†½W¦å·å¼•ç”¨è½¬æˆç›´æŽ¥å¼•ç”¨åQ?/p>

初始化：‹È€‹zȝ±»çš„静态变量的初始化Java代码和静态Java代码å?/p>

十六˜q›åˆ¶å€?/p>

 
　　解决的方法：

　　replace() æ–ÒŽ³•å¦‚果直接用str.replace("-","!") 只会替换½W¬ä¸€ä¸ªåŒ¹é…çš„字符.

　　而str.replace(/\-/g,"!")则可以替换掉全部匚w…çš„å­—½W?g为全局标志)ã€?/p>

　　replace()

　　js中替换字½W¦å˜é‡å¦‚下：

　　data2=data2.replace(/\%/g,"%25");

　　data2=data2.replace(/\#/g,"%23");

　　data2=data2.replace(/\&/g,"%26");

1. 寄存器：我们在程序中无法控制
2. 栈：存放基本¾cÕdž‹çš„数据和对象的引用，但对象本íw«ä¸å­˜æ”¾åœ¨æ ˆä¸­ï¼Œè€Œæ˜¯å­˜æ”¾åœ¨å †ä¸?br />3. 堆：存放用new产生的数æ?br />4. 静态域åQšå­˜æ”‘Öœ¨å¯¹è±¡ä¸­ç”¨static定义的静态成å‘?br />5. 帔R‡æ± ï¼šå­˜æ”¾å¸”R‡
6. 非RAM(随机存取存储å™?/span>)存储åQšç¡¬ç›˜ç­‰æ°æ€¹…存储½Iºé—´
----------------------------------------------------------------------------------------------------------------------

a.在函æ•îC¸­å®šä¹‰çš„一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配ã€?nbsp; 
当在一ŒDµä»£ç å—定义一个变量时åQŒJavaž®±åœ¨æ ˆä¸­ä¸ø™¿™ä¸ªå˜é‡åˆ†é…å†…存空é—ß_¼Œå½“该变量退å‡ø™¯¥ä½œç”¨åŸŸåŽåQŒJava会自动释放掉ä¸ø™¯¥å˜é‡æ‰€åˆ†é…çš„内存空é—ß_¼Œè¯¥å†…存空间可以立卌™¢«å¦ä½œä»–用ã€?nbsp; 
b.堆内存用来存攄¡”±new创徏的对象和数组ã€?nbsp;在堆中分配的内存åQŒç”±Java虚拟机的自动垃圾回收器来½Ž¡ç†ã€?nbsp; 
在堆中äñ”生了一个数¾l„或对象后，˜q˜å¯ä»¥åœ¨æ ˆä¸­å®šä¹‰ä¸€ä¸ªç‰¹ŒDŠçš„变量åQŒè®©æ ˆä¸­˜q™ä¸ªå˜é‡çš„取值等于数¾l„或对象在堆内存中的首地址åQŒæ ˆä¸­çš„˜q™ä¸ªå˜é‡ž®±æˆäº†æ•°¾l„或对象的引用变量ã€?nbsp; å¼•ç”¨å˜é‡ž®Þq›¸å½“于是äؓ数组或对象è“v的一个名¿UŽÍ¼Œä»¥åŽž®±å¯ä»¥åœ¨½E‹åºä¸­ä‹É用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是ä¸?数组或者对象è“v的一个名¿U°ã€‚引用变量是普通的变量åQŒå®šä¹‰æ—¶åœ¨æ ˆä¸­åˆ†é…ï¼Œå¼•ç”¨å˜é‡åœ¨ç¨‹åºè¿è¡Œåˆ°å…¶ä½œç”¨åŸŸä¹‹å¤–后被释放。而数¾l„和对象本èín在堆中分配，即ä‹É½E‹åº˜qè¡ŒåˆîC‹Éç”?new 产生数组或者对象的语句所在的代码块之外，数组和对象本íw«å æ®çš„内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用åQŒä½†ä»ç„¶å æ®å†…å­˜½Iºé—´ä¸æ”¾åQŒåœ¨éšåŽçš„一个不¼‹®å®šçš„时间被垃圾回收器收赎ͼˆé‡Šæ”¾æŽ‰ï¼‰ã€‚这也是 Java æ¯”较占内存的原因ã€?nbsp;
实际上，栈中的变量指向堆内存中的变量åQŒè¿™ž®±æ˜¯ Java ä¸­çš„指针åQ?nbsp;
c.帔R‡æ±?/span>(constant pool)指的是在¾~–译期被¼‹®å®šåQŒåƈ被保存在已编译的.classæ–‡äšg中的一些数据。除了包含代码中所定义的各¿UåŸºæœ¬ç±»åž‹ï¼ˆå¦‚int、long½{‰ç­‰åQ‰å’Œå¯¹è±¡åž‹ï¼ˆå¦‚String及数¾l„）的常量å€?final)˜q˜åŒ…含一些以文本形式出现的符号引用，比如åQ?¾cÕd’ŒæŽ¥å£çš„全限定名； 字段的名¿U°å’Œæè¿°½W¦ï¼› æ–ÒŽ³•å’Œå¿U°å’Œæè¿°½W¦ã€?虚拟机必™åÖMؓ每个被装载的¾cÕdž‹¾l´æŠ¤ä¸€ä¸ªå¸¸é‡æ± ã€‚常量池ž®±æ˜¯è¯¥ç±»åž‹æ‰€ç”¨åˆ°å¸”R‡çš„一个有序集和，包括直接帔R‡åQˆstring,integerå’Œfloating point帔R‡åQ‰å’Œå¯¹å…¶ä»–类型，字段和方法的½W¦å·å¼•ç”¨ã€‚对于String帔R‡åQŒå®ƒçš„值是在常量池中的。而JVM中的帔R‡æ± åœ¨å†…存当中是以表的形式存在的，对于String¾cÕdž‹åQŒæœ‰ä¸€å¼ å›ºå®šé•¿åº¦çš„CONSTANT_String_info表用来存储文字字½W¦ä¸²å€û|¼Œæ³¨æ„åQšè¯¥è¡¨åªå­˜å‚¨æ–‡å­—字符串å€û|¼Œä¸å­˜å‚¨ç¬¦å·å¼•ç”¨ã€‚说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了ã€?/p>

在程序执行的时å€?帔R‡æ±?/span>会储存在Method Area,而不是堆ä¸?
d.Java的堆是一个运行时数据åŒ?¾cȝš„(对象从中分配½Iºé—´ã€‚这些对象通过new、newarray、anewarrayå’Œmultianewarray½{‰æŒ‡ä»¤å¾ç«‹ï¼Œå®ƒä»¬ä¸éœ€è¦ç¨‹åºä»£ç æ¥æ˜‘Ö¼çš„释放。堆是由垃圾回收来负责的åQŒå †çš„优势是可以动态地分配内存大小åQŒç”Ÿå­˜æœŸä¹Ÿä¸å¿…事先告诉编译器åQŒå› ä¸ºå®ƒæ˜¯åœ¨˜qè¡Œæ—¶åŠ¨æ€åˆ†é…å†…存的åQŒJava的垃圾收集器会自动收走这些不再ä‹É用的数据。但¾~ºç‚¹æ˜¯ï¼Œç”׃ºŽè¦åœ¨˜qè¡Œæ—¶åŠ¨æ€åˆ†é…å†…存，存取速度较慢ã€?nbsp;

栈的优势是，存取速度比堆要快åQŒä»…‹Æ¡äºŽå¯„存器，栈数据可以共享。但¾~ºç‚¹æ˜¯ï¼Œå­˜åœ¨æ ˆä¸­çš„数据大ž®ä¸Žç”Ÿå­˜æœŸå¿…™åÀL˜¯¼‹®å®šçš„，¾~ÞZ¹ç‰|´»æ€§ã€‚栈中主要存放一些基本类型的变量数据åQˆint, short, long, byte, float, double, boolean, charåQ‰å’Œå¯¹è±¡å¥æŸ„(引用)ã€?nbsp;

栈有一个很重要的特ŒDŠæ€§ï¼Œž®±æ˜¯å­˜åœ¨æ ˆä¸­çš„数据可以共享。假设我们同时定义： 
int a = 3; 
int b = 3åQ?nbsp;
¾~–译器先处理int a = 3åQ›é¦–先它会在栈中创徏一个变量äØ“a的引用，然后查找栈中是否æœ?˜q™ä¸ªå€û|¼Œå¦‚果没找刎ͼŒž®±å°†3存放˜q›æ¥åQŒç„¶åŽå°†a指向3。接着处理int b = 3åQ›åœ¨åˆ›å¾å®Œb的引用变量后åQŒå› ä¸ºåœ¨æ ˆä¸­å·²ç»æœ?˜q™ä¸ªå€û|¼Œä¾¿å°†b直接指向3。这æ øP¼Œž®±å‡ºçŽîCº†a与b同时均指å?的情å†üc€?nbsp;

˜q™æ—¶åQŒå¦‚果再令a=4åQ›é‚£ä¹ˆç¼–译器会重新搜索栈中是否有4å€û|¼Œå¦‚果没有åQŒåˆ™ž®?存放˜q›æ¥åQŒåƈ令a指向4åQ›å¦‚果已¾læœ‰äº†ï¼Œåˆ™ç›´æŽ¥å°†a指向˜q™ä¸ªåœ°å€ã€‚å› æ­¤a值的改变不会影响到b的倹{€?nbsp;

要注意这¿Uæ•°æ®çš„å…׃ín与两个对象的引用同时指向一个对象的˜q™ç§å…׃ín是不同的åQŒå› ä¸ø™¿™¿Uæƒ…况a的修改åƈ不会影响到b, 它是ç”Þq¼–译器完成的，它有利于节省½Iºé—´ã€‚而一个对象引用变量修改了˜q™ä¸ªå¯¹è±¡çš„内部状态，会媄响到另一个对象引用变量ã€?/p>

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

String是一个特ŒDŠçš„包装¾cÀL•°æ®ã€‚可以用åQ?nbsp;
String str = new String("abc"); 
String str = "abc"; 
两种的åŞ式来创徏åQŒç¬¬ä¸€¿Uæ˜¯ç”¨new()来新建对象的åQŒå®ƒä¼šåœ¨å­˜æ”¾äºŽå †ä¸­ã€‚每调用一‹Æ¡å°±ä¼šåˆ›å»ÞZ¸€ä¸ªæ–°çš„对象ã€?nbsp;
而第二种是先在栈中创å»ÞZ¸€ä¸ªå¯¹String¾cȝš„对象引用变量stråQŒç„¶åŽé€šè¿‡½W¦å·å¼•ç”¨åŽ?span style="color: #ff0000;">字符串常量池里找有没æœ?abc",如果没有åQŒåˆ™ž®?abc"存放˜q?span style="color: #ff0000;">字符串常量池åQŒåƈ令str指向”abc”åQŒå¦‚果已¾læœ‰”abc” 则直接ä×ostr指向“abc”ã€?nbsp;

比较¾c»é‡Œé¢çš„数值是否相½{‰æ—¶åQŒç”¨equals()æ–ÒŽ³•åQ›å½“‹¹‹è¯•ä¸¤ä¸ªåŒ…装¾cȝš„引用是否指向同一个对象时åQŒç”¨==åQŒä¸‹é¢ç”¨ä¾‹å­è¯´æ˜Žä¸Šé¢çš„理论ã€?nbsp;
String str1 = "abc"; 
String str2 = "abc"; 
System.out.println(str1==str2); //true 
可以看出str1和str2是指向同一个对象的�nbsp;

String str1 =new String ("abc"); 
String str2 =new String ("abc"); 
System.out.println(str1==str2); // false 
用new的方式是生成不同的对象。每一‹Æ¡ç”Ÿæˆä¸€ä¸ªã€?nbsp;

因此用第二种方式创徏多个”abc”字符ä¸?在内存中其实只存在一个对象而已. ˜q™ç§å†™æ³•æœ‰åˆ©ä¸ŽèŠ‚省内存空é—? 同时它可以在一定程度上提高½E‹åºçš„运行速度åQŒå› ä¸ºJVM会自动根据栈中数据的实际情况来决定是否有必要创徏新对象。而对于String str = new String("abc")åQ›çš„代码åQŒåˆ™ä¸€æ¦‚在堆中创徏新对象，而不½Ž¡å…¶å­—符串值是否相½{‰ï¼Œæ˜¯å¦æœ‰å¿…要创建新对象åQŒä»Žè€ŒåŠ é‡äº†½E‹åºçš„è´Ÿæ‹…ã€?nbsp;

另一斚w¢, 要注æ„? 我们在ä‹É用诸如String str = "abc"åQ›çš„格式定义¾cÀL—¶åQŒæ€ÀL˜¯æƒ›_½“然地认äØ“åQŒåˆ›å»ÞZº†String¾cȝš„对象str。担心陷阱！对象可能òq¶æ²¡æœ‰è¢«åˆ›å¾åQè€Œå¯èƒ½åªæ˜¯æŒ‡å‘一个先前已¾låˆ›å»ºçš„对象。只有通过new()æ–ÒŽ³•æ‰èƒ½ä¿è¯æ¯æ¬¡éƒ½åˆ›å»ÞZ¸€ä¸ªæ–°çš„对象ã€?nbsp;
ç”׃ºŽString¾cȝš„immutable性质åQŒå½“String变量需要经常变换其值时åQŒåº”该考虑使用StringBuffer¾c»ï¼Œä»¥æé«˜ç¨‹åºæ•ˆçŽ‡ã€?nbsp;
1. 首先String不属äº?¿UåŸºæœ¬æ•°æ®ç±»åž‹ï¼ŒString是一个对象ã€?nbsp;
å› äؓ对象的默认值是nullåQŒæ‰€ä»¥String的默认å€ég¹Ÿæ˜¯nullåQ›ä½†å®ƒåˆæ˜¯ä¸€¿Uç‰¹ŒDŠçš„对象åQŒæœ‰å…¶å®ƒå¯¹è±¡æ²¡æœ‰çš„一些特性ã€?nbsp;

2. new String()å’Œnew String(”")都是ç”Ïx˜Žä¸€ä¸ªæ–°çš„空字符ä¸ÔŒ¼Œæ˜¯ç©ºä¸²ä¸æ˜¯nullåQ?nbsp;

3. String str=”kvill”åQ›String str=new String (”kvill”)的区åˆ?br />
看例1åQ?nbsp;

String s0="kvill"; 
String s1="kvill"; 
String s2="kv" + "ill"; 
System.out.println( s0==s1 ); 
System.out.println( s0==s2 ); 
¾l“果为： 
true 
true 

首先åQŒæˆ‘们要知结果äØ“é?span style="background-color: #ffff00;">Java会确保一个字½W¦ä¸²å¸”R‡åªæœ‰ä¸€ä¸ªæ‹·è´ã€?nbsp;
å› äؓ例子中的s0å’Œs1中的”kvill”都是字符串常量，它们在编译期ž®Þp¢«¼‹®å®šäº†ï¼Œæ‰€ä»¥s0==s1为trueåQ›è€?#8221;kv”å’?#8221;ill”也都是字½W¦ä¸²å¸”R‡åQŒå½“一个字½W¦ä¸²ç”±å¤šä¸ªå­—½W¦ä¸²å¸”R‡˜qžæŽ¥è€Œæˆæ—Óž¼Œå®ƒè‡ªå·Þp‚¯å®šä¹Ÿæ˜¯å­—½W¦ä¸²å¸”R‡åQŒæ‰€ä»¥s2也同样在¾~–译期就被解析äؓ一个字½W¦ä¸²å¸”R‡åQŒæ‰€ä»¥s2也是帔R‡æ± ä¸­” kvill”的一个引用。所以我们得出s0==s1==s2åQ›ç”¨new String() 创徏的字½W¦ä¸²ä¸æ˜¯å¸”R‡åQŒä¸èƒ½åœ¨¾~–译期就¼‹®å®šåQŒæ‰€ä»¥new String() 创徏的字½W¦ä¸²ä¸æ”¾å…¥å¸¸é‡æ± ä¸­ï¼Œå®ƒä»¬æœ‰è‡ªå·Þqš„地址½Iºé—´ã€?nbsp;

看例2åQ?nbsp;
String s0="kvill"; 
String s1=new String("kvill"); 
String s2="kv" + new String("ill"); 
System.out.println( s0==s1 ); 
System.out.println( s0==s2 ); 
System.out.println( s1==s2 ); 
¾l“果为： 
false 
false 
false 

ä¾?中s0˜q˜æ˜¯å¸”R‡æ± ä¸­"kvill”的应用，s1å› äؓ无法在编译期¼‹®å®šåQŒæ‰€ä»¥æ˜¯˜qè¡Œæ—¶åˆ›å»ºçš„新对è±?#8221;kvill”的引用，s2å› äؓ有后半部åˆ?new String(”ill”)所以也无法在编译期¼‹®å®šåQŒæ‰€ä»¥ä¹Ÿæ˜¯ä¸€ä¸ªæ–°åˆ›å¾å¯¹è±¡”kvill”的应ç”?明白了这些也ž®ÞqŸ¥é“äؓ何得出此¾l“果了ã€?nbsp;

4. String.intern()åQ?nbsp;
再补充介¾lä¸€ç‚¹ï¼šå­˜åœ¨äº?classæ–‡äšg中的帔R‡æ± ï¼Œåœ¨è¿è¡ŒæœŸè¢«JVM装蝲åQŒåƈ且可以扩充。Stringçš„intern()æ–ÒŽ³•ž®±æ˜¯æ‰©å……帔R‡æ± çš„ 一个方法；当一个String实例str调用intern()æ–ÒŽ³•æ—Óž¼ŒJava查找帔R‡æ± ä¸­æ˜¯å¦æœ‰ç›¸åŒUnicodeçš„å­—½W¦ä¸²å¸”R‡åQŒå¦‚果有åQŒåˆ™˜q”回其的引用åQŒå¦‚果没有，则在帔R‡æ± ä¸­å¢žåŠ ä¸€ä¸ªUnicode½{‰äºŽstrçš„å­—½W¦ä¸²òq¶è¿”回它的引用；看例3ž®±æ¸…楚了 

ä¾?åQ?nbsp;
String s0= "kvill"; 
String s1=new String("kvill"); 
String s2=new String("kvill"); 
System.out.println( s0==s1 ); 
System.out.println( "**********" ); 
s1.intern(); 
s2=s2.intern(); //把常量池ä¸?kvill"的引用赋¾l™s2 
System.out.println( s0==s1); 
System.out.println( s0==s1.intern() ); 
System.out.println( s0==s2 ); 
¾l“果为： 
false 
********** 
false //虽然执行了s1.intern(),但它的返回值没有赋¾l™s1 
true //说明s1.intern()˜q”回的是帔R‡æ± ä¸­"kvill"的引ç”?nbsp;
true 

最后我再破除一个错误的理解åQšæœ‰äºø™¯´åQ?#8220;使用 String.intern() æ–ÒŽ³•åˆ™å¯ä»¥å°†ä¸€ä¸?String ¾cȝš„保存åˆîC¸€ä¸ªå…¨å±€ String 表中 åQŒå¦‚果具有相同值的 Unicode 字符串已¾låœ¨˜q™ä¸ªè¡¨ä¸­åQŒé‚£ä¹ˆè¯¥æ–ÒŽ³•˜q”回表中已有字符串的地址åQŒå¦‚果在表中没有相同值的字符ä¸ÔŒ¼Œåˆ™å°†è‡ªå·±çš„地址注册到表ä¸?#8221;如果我把他说的这个全局çš?String 表理解äؓ帔R‡æ± çš„话，他的最后一句话åQ?#8221;如果在表中没有相同值的字符ä¸ÔŒ¼Œåˆ™å°†è‡ªå·±çš„地址注册到表ä¸?#8221;是错的： 

看例4åQ?nbsp;
String s1=new String("kvill"); 
String s2=s1.intern(); 
System.out.println( s1==s1.intern() ); 
System.out.println( s1+" "+s2 ); 
System.out.println( s2==s1.intern() ); 
¾l“æžœåQ?nbsp;
false 
kvill kvill 
true 

在这个类中我们没有声名一ä¸?#8221;kvill”帔R‡åQŒæ‰€ä»¥å¸¸é‡æ± ä¸­ä¸€å¼€å§‹æ˜¯æ²¡æœ‰”kvill”的，当我们调用s1.intern()后就在常量池中新æ·ÕdŠ äº†ä¸€ä¸?#8221;kvill”帔R‡åQŒåŽŸæ¥çš„不在帔R‡æ± ä¸­çš?#8221;kvill”仍然存在åQŒä¹Ÿž®×ƒ¸æ˜?#8220;ž®†è‡ªå·Þqš„地址注册到常量池ä¸?#8221;了ã€?nbsp;
s1==s1.intern()为false说明原来çš?#8221;kvill”仍然存在åQ›s2现在为常量池ä¸?#8221;kvill”的地址åQŒæ‰€ä»¥æœ‰s2==s1.intern()为trueã€?nbsp;

5. 关于equals()å’?=: 
˜q™ä¸ªå¯¹äºŽString½Ž€å•æ¥è¯´å°±æ˜¯æ¯”较两字符串的Unicode序列是否相当åQŒå¦‚果相½{‰è¿”回true;è€?=是比较两字符串的地址是否相同åQŒä¹Ÿž®±æ˜¯æ˜¯å¦æ˜¯åŒä¸€ä¸ªå­—½W¦ä¸²çš„引用ã€?nbsp;

6. 关于String是不可变�nbsp;
˜q™ä¸€è¯´åˆè¦è¯´å¾ˆå¤šåQŒå¤§å®¶åªè¦çŸ¥é“String的实例一旦生成就不会再改变了åQŒæ¯”如说åQšString str=”kv”+”ill”+” “+”ans”; ž®±æ˜¯æœ?个字½W¦ä¸²å¸”R‡åQŒé¦–å…?#8221;kv”å’?#8221;ill”生成äº?#8221;kvill”存在内存中，然后”kvill”又和” ” 生成 “kvill “存在内存中，最后又和生成了”kvill ans”;òq¶æŠŠ˜q™ä¸ªå­—符串的地址赋给了str,ž®±æ˜¯å› äØ“Stringçš?#8221;不可å?#8221;产生了很多äÍ时变量，˜q™ä¹Ÿž®±æ˜¯ä¸ÞZ»€ä¹ˆå¾è®®ç”¨StringBuffer的原因了åQŒå› ä¸ºStringBuffer是可改变的ã€?/p>

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

下面是一些String相关的常见问题：

String中的final用法和理�br />final StringBuffer a = new StringBuffer("111");
final StringBuffer b = new StringBuffer("222");
a=b;//此句¾~–译不通过

final StringBuffer a = new StringBuffer("111");
a.append("222");//¾~–译通过

可见åQŒfinal只对引用çš?å€?(卛_†…存地址)有效åQŒå®ƒ˜q«ä‹É引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化åQŒfinal是不负责的ã€?/p>

String 帔R‡æ± é—®é¢˜çš„几个例子

下面是几个常见例子的比较分析和理解：
[1]
String a = "a1"; 
String b = "a" + 1; 
System.out.println((a == b)); //result = true
String a = "atrue"; 
String b = "a" + "true"; 
System.out.println((a == b)); //result = true
String a = "a3.4"; 
String b = "a" + 3.4; 
System.out.println((a == b)); //result = true

分析åQšJVM对于字符串常量的"+"可‚¿žæŽ¥ï¼Œž®†ç¨‹åºç¼–译期åQŒJVMž®±å°†å¸”R‡å­—符串的"+"˜qžæŽ¥ä¼˜åŒ–ä¸ø™¿žæŽ¥åŽçš„å€û|¼Œæ‹?a" + 1来说åQŒç»¾~–译器优化后在class中就已经是a1。在¾~–译期其字符串常量的值就¼‹®å®šä¸‹æ¥åQŒæ•…上面½E‹åºæœ€¾lˆçš„¾l“果都äØ“trueã€?/p>

[2]
String a = "ab"; 
String bb = "b"; 
String b = "a" + bb; 
System.out.println((a == b)); //result = false

分析åQšJVM对于字符串引用，ç”׃ºŽåœ¨å­—½W¦ä¸²çš?+"˜qžæŽ¥ä¸­ï¼Œæœ‰å­—½W¦ä¸²å¼•ç”¨å­˜åœ¨åQŒè€Œå¼•ç”¨çš„值在½E‹åº¾~–译期是无法¼‹®å®šçš„，å?a" + bb无法被编译器优化åQŒåªæœ‰åœ¨½E‹åº˜qè¡ŒæœŸæ¥åŠ¨æ€åˆ†é…åƈž®†è¿žæŽ¥åŽçš„新地址赋给b。所以上面程序的¾l“果也就为falseã€?/p>

[3]
String a = "ab"; 
final String bb = "b"; 
String b = "a" + bb; 
System.out.println((a == b)); //result = true

分析åQšå’Œ[3]中唯一不同的是bb字符串加了final修饰åQŒå¯¹äºŽfinal修饰的变量，它在¾~–译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码‹¹ä¸­ã€‚所以此时的"a" + bbå’?a" + "b"效果是一æ ïLš„。故上面½E‹åºçš„结果äØ“trueã€?/p>

[4]
String a = "ab"; 
final String bb = getBB(); 
String b = "a" + bb; 
System.out.println((a == b)); //result = false 
private static String getBB() {
return "b"; 
}

分析åQšJVM对于字符串引用bbåQŒå®ƒçš„值在¾~–译期无法确定，只有在程序运行期调用æ–ÒŽ³•åŽï¼Œž®†æ–¹æ³•çš„˜q”回值和"a"来动态连接åƈ分配地址为båQŒæ•…上面½E‹åºçš„结果äØ“falseã€?/p>

通过上面4个例子可以得出得知：
String  s  =  "a" + "b" + "c";   
ž®Þq­‰ä»·äºŽString s = "abc";   

String  a  =  "a";   
String  b  =  "b";   
String  c  =  "c";   
String  s  =   a  +  b  +  c;  

˜q™ä¸ªž®×ƒ¸ä¸€æ ·äº†åQŒæœ€¾lˆç»“果等于：   
StringBuffer temp = new StringBuffer();   
temp.append(a).append(b).append(c);   
String s = temp.toString();

ç”׃¸Šé¢çš„分析¾l“æžœåQŒå¯ž®×ƒ¸éš¾æŽ¨æ–­å‡ºString 采用˜qžæŽ¥˜qç®—½W¦ï¼ˆ+åQ‰æ•ˆçŽ‡ä½Žä¸‹åŽŸå› åˆ†æžï¼Œå½¢å¦‚˜q™æ ·çš„代码：

public class Test {
public static void main(String args[]) {
String s = null;
for(int i = 0; i < 100; i++) {
s += "a";
}
}
}

每做一‹Æ?+ ž®×ƒñ”生个StringBuilder对象åQŒç„¶åŽappend后就扔掉。下‹Æ¡åó@环再到达旉™‡æ–îCñ”生个StringBuilder对象åQŒç„¶å?append 字符ä¸ÔŒ¼Œå¦‚此循环直至¾l“束ã€?如果我们直接采用 StringBuilder 对象˜q›è¡Œ append 的话åQŒæˆ‘们可以节çœ?N - 1 ‹Æ¡åˆ›å»ºå’Œé”€æ¯å¯¹è±¡çš„æ—‰™—´ã€‚所以对于在循环中要˜q›è¡Œå­—符串连接的应用åQŒä¸€èˆ¬éƒ½æ˜¯ç”¨StringBuffer或StringBulider对象来进行append操作ã€?/p>

String对象的internæ–ÒŽ³•ç†è§£å’Œåˆ†æžï¼š

public class Test4 {
private static String a = "ab"; 
public static void main(String[] args){
String s1 = "a";
String s2 = "b";
String s = s1 + s2;
System.out.println(s == a);//false
System.out.println(s.intern() == a);//true  
}
}

˜q™é‡Œç”¨åˆ°Java里面是一个常量池的问题。对于s1+s2操作åQŒå…¶å®žæ˜¯åœ¨å †é‡Œé¢é‡æ–°åˆ›å¾äº†ä¸€ä¸ªæ–°çš„对è±?s保存的是˜q™ä¸ªæ–°å¯¹è±¡åœ¨å †ç©ºé—´çš„的内容，所以s与a的值是不相½{‰çš„。而当调用s.intern()æ–ÒŽ³•åQŒå´å¯ä»¥˜q”回s在常量池中的地址å€û|¼Œå› äØ“a的值存储在帔R‡æ± ä¸­åQŒæ•…s.internå’Œa的值相½{?/p>

æ€È»“:

a.栈中用来存放一些原始数据类型的局部变量数据和对象的引ç”?String,数组.对象½{‰ç­‰)但不存放对象内容

b.堆中存放使用new关键字创建的对象.

c.字符串是一个特ŒDŠåŒ…装类,其引用是存放在栈里的,而对象内容必™åÀL ¹æ®åˆ›å»ºæ–¹å¼ä¸åŒå®š(帔R‡æ± å’Œå ?.有的是编译期ž®±å·²¾låˆ›å»ºå¥½åQŒå­˜æ”‘Öœ¨å­—符串常量池中，而有的是˜qè¡Œæ—¶æ‰è¢«åˆ›å»?使用new关键字，存放在堆中ã€?/p>

本文转自åQ?a style="color: #ff9900; text-decoration: initial;">http://zy19880423.javaeye.com/blog/434179

多态表现在重蝲åQŒä¸€ä¸ªçˆ¶¾cȝš„变量可以引用子类的对è±?/p>

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.util.zip.CRC32;
import java.util.zip.CheckedOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class CreateZip {
 public static String createZipFile(String filePath){
  String result="failure";
  try {
   FileOutputStream fileOut=new FileOutputStream("example.zip");
   CheckedOutputStream checkOut=new CheckedOutputStream(fileOut,new CRC32());
   ZipOutputStream zipOut=new ZipOutputStream(new BufferedOutputStream(checkOut));
   
   BufferedReader in=new BufferedReader(new FileReader(filePath));
   zipOut.putNextEntry(new ZipEntry(filePath));
   int line;
   while((line=in.read())!=-1){
    zipOut.write(line);
    zipOut.flush();
   }
   result="success";
   in.close();
   zipOut.close();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }
 public static void main(String[] args) {
  String fileName="D:\\abin.txt";
  String result=createZipFile(fileName);
  System.out.println("result="+result);
 }
}

public class Can implements Cloneable{
 private int id;
 private String address;
 public Can() {
 }
 public Can(int id, String address) {
  super();
  this.id = id;
  this.address = address;
 }
 public Object clone()throws CloneNotSupportedException{
  return super.clone();
 }
 public int hashCode(){
  final int prime=31;
  int result=1;
  result=prime*result+id;
  result=prime*result+((address==null?0:address.hashCode()));
  return result;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 
}

package net.abin.lee.basic;

import junit.framework.TestCase;

public class UserTest extends TestCase{
 public void test1() throws CloneNotSupportedException{
  User user1=new User("12","abin",3);
  User user2=user1;
  User user3=(User)user1.clone();
  System.out.println("user1=user2 :"+(user1==user2));
  System.out.println("user1equalsuser2 :"+(user1.equals(user2)));
  
  System.out.println("user1=user3 :"+(user1==user3));
  System.out.println("user1equalsuser3 :"+(user1.equals(user3)));
  
 }
 @Override
 protected void runTest() throws Throwable {
  System.out.println("55");
  super.runTest();
 }
}

package com.abin.lee.collection.singleton;

public class SingletonTwo {
 /**
  * volatile关键词确保：当uniqueInstance变量被初始化成Singleton实例æ—Óž¼Œ
  * 多个¾U¿ç¨‹æ­£ç¡®åœ°å¤„理uniqueInstance变量
  */
 private volatile static SingletonTwo singleton = new SingletonTwo();

 private SingletonTwo() {
 }

 public static SingletonTwo getInstance() {
  return singleton;
 }
}

验证的代码：

  return ((this.getId() == castOther.getId()) || (this.getId() != null
    && castOther.getId() != null && this.getId().equals(
    castOther.getId())))
    && ((this.getPartner() == castOther.getPartner()) || (this
      .getPartner() != null
      && castOther.getPartner() != null && this.getPartner()
      .equals(castOther.getPartner())))
    && ((this.getDiscount() == castOther.getDiscount()) || (this
      .getDiscount() != null
      && castOther.getDiscount() != null && this
      .getDiscount().equals(castOther.getDiscount())))
    && ((this.getPaymentType() == castOther.getPaymentType()) || (this
      .getPaymentType() != null
      && castOther.getPaymentType() != null && this
      .getPaymentType().equals(castOther.getPaymentType())))
    && ((this.getSubject() == castOther.getSubject()) || (this
      .getSubject() != null
      && castOther.getSubject() != null && this.getSubject()
      .equals(castOther.getSubject())))
    && ((this.getTradeNo() == castOther.getTradeNo()) || (this
      .getTradeNo() != null
      && castOther.getTradeNo() != null && this.getTradeNo()
      .equals(castOther.getTradeNo())))
    && ((this.getBuyerEmail() == castOther.getBuyerEmail()) || (this
      .getBuyerEmail() != null
      && castOther.getBuyerEmail() != null && this
      .getBuyerEmail().equals(castOther.getBuyerEmail())))
    && ((this.getGmtCreate() == castOther.getGmtCreate()) || (this
      .getGmtCreate() != null
      && castOther.getGmtCreate() != null && this
      .getGmtCreate().equals(castOther.getGmtCreate())))
    && ((this.getQuantity() == castOther.getQuantity()) || (this
      .getQuantity() != null
      && castOther.getQuantity() != null && this
      .getQuantity().equals(castOther.getQuantity())))
    && ((this.getOutTradeNo() == castOther.getOutTradeNo()) || (this
      .getOutTradeNo() != null
      && castOther.getOutTradeNo() != null && this
      .getOutTradeNo().equals(castOther.getOutTradeNo())))
    && ((this.getSellerId() == castOther.getSellerId()) || (this
      .getSellerId() != null
      && castOther.getSellerId() != null && this
      .getSellerId().equals(castOther.getSellerId())))
    && ((this.getTradeStatus() == castOther.getTradeStatus()) || (this
      .getTradeStatus() != null
      && castOther.getTradeStatus() != null && this
      .getTradeStatus().equals(castOther.getTradeStatus())))
    && ((this.getIsTotalFeeAdjust() == castOther
      .getIsTotalFeeAdjust()) || (this.getIsTotalFeeAdjust() != null
      && castOther.getIsTotalFeeAdjust() != null && this
      .getIsTotalFeeAdjust().equals(
        castOther.getIsTotalFeeAdjust())))
    && ((this.getTotalFee() == castOther.getTotalFee()) || (this
      .getTotalFee() != null
      && castOther.getTotalFee() != null && this
      .getTotalFee().equals(castOther.getTotalFee())))
    && ((this.getGmtPayment() == castOther.getGmtPayment()) || (this
      .getGmtPayment() != null
      && castOther.getGmtPayment() != null && this
      .getGmtPayment().equals(castOther.getGmtPayment())))
    && ((this.getSellerEmail() == castOther.getSellerEmail()) || (this
      .getSellerEmail() != null
      && castOther.getSellerEmail() != null && this
      .getSellerEmail().equals(castOther.getSellerEmail())))
    && ((this.getGmtClose() == castOther.getGmtClose()) || (this
      .getGmtClose() != null
      && castOther.getGmtClose() != null && this
      .getGmtClose().equals(castOther.getGmtClose())))
    && ((this.getPrice() == castOther.getPrice()) || (this
      .getPrice() != null
      && castOther.getPrice() != null && this.getPrice()
      .equals(castOther.getPrice())))
    && ((this.getBuyerId() == castOther.getBuyerId()) || (this
      .getBuyerId() != null
      && castOther.getBuyerId() != null && this.getBuyerId()
      .equals(castOther.getBuyerId())))
    && ((this.getUseCoupon() == castOther.getUseCoupon()) || (this
      .getUseCoupon() != null
      && castOther.getUseCoupon() != null && this
      .getUseCoupon().equals(castOther.getUseCoupon())))
    && ((this.getCreateTime() == castOther.getCreateTime()) || (this
      .getCreateTime() != null
      && castOther.getCreateTime() != null && this
      .getCreateTime().equals(castOther.getCreateTime())))
    && ((this.getLastUpdateTime() == castOther.getLastUpdateTime()) || (this
      .getLastUpdateTime() != null
      && castOther.getLastUpdateTime() != null && this
      .getLastUpdateTime().equals(
        castOther.getLastUpdateTime())))
    && ((this.getPaymentMethod() == castOther.getPaymentMethod()) || (this
      .getPaymentMethod() != null
      && castOther.getPaymentMethod() != null && this
      .getPaymentMethod()
      .equals(castOther.getPaymentMethod())));
 }

 public int hashCode() {
  int result = 17;

  result = 37 * result + (getId() == null ? 0 : this.getId().hashCode());
  result = 37 * result
    + (getPartner() == null ? 0 : this.getPartner().hashCode());
  result = 37 * result
    + (getDiscount() == null ? 0 : this.getDiscount().hashCode());
  result = 37
    * result
    + (getPaymentType() == null ? 0 : this.getPaymentType()
      .hashCode());
  result = 37 * result
    + (getSubject() == null ? 0 : this.getSubject().hashCode());
  result = 37 * result
    + (getTradeNo() == null ? 0 : this.getTradeNo().hashCode());
  result = 37
    * result
    + (getBuyerEmail() == null ? 0 : this.getBuyerEmail()
      .hashCode());
  result = 37 * result
    + (getGmtCreate() == null ? 0 : this.getGmtCreate().hashCode());
  result = 37 * result
    + (getQuantity() == null ? 0 : this.getQuantity().hashCode());
  result = 37
    * result
    + (getOutTradeNo() == null ? 0 : this.getOutTradeNo()
      .hashCode());
  result = 37 * result
    + (getSellerId() == null ? 0 : this.getSellerId().hashCode());
  result = 37
    * result
    + (getTradeStatus() == null ? 0 : this.getTradeStatus()
      .hashCode());
  result = 37
    * result
    + (getIsTotalFeeAdjust() == null ? 0 : this
      .getIsTotalFeeAdjust().hashCode());
  result = 37 * result
    + (getTotalFee() == null ? 0 : this.getTotalFee().hashCode());
  result = 37
    * result
    + (getGmtPayment() == null ? 0 : this.getGmtPayment()
      .hashCode());
  result = 37
    * result
    + (getSellerEmail() == null ? 0 : this.getSellerEmail()
      .hashCode());
  result = 37 * result
    + (getGmtClose() == null ? 0 : this.getGmtClose().hashCode());
  result = 37 * result
    + (getPrice() == null ? 0 : this.getPrice().hashCode());
  result = 37 * result
    + (getBuyerId() == null ? 0 : this.getBuyerId().hashCode());
  result = 37 * result
    + (getUseCoupon() == null ? 0 : this.getUseCoupon().hashCode());
  result = 37
    * result
    + (getCreateTime() == null ? 0 : this.getCreateTime()
      .hashCode());
  result = 37
    * result
    + (getLastUpdateTime() == null ? 0 : this.getLastUpdateTime()
      .hashCode());
  result = 37
    * result
    + (getPaymentMethod() == null ? 0 : this.getPaymentMethod()
      .hashCode());
  return result;
 }