表达式陷阱（字符串，表达式类型，输入法，注释字符，转义字符，正则表达式）

1.    表达式中的陷阱
1.1  关于字符串的陷阱
1. 在创建一个String s = new String("java");的时候，JVM会到常量池中去检查看是否有一个"java"对象了，如果没有则在常量池中创建一个。之后会在堆内存中分配了一个空间，放置这个new出来的String对象，形式如下：java.lang.String@123b， 常量池是在编译期生成的，而new一个对象是在运行时进行的，有一个先后顺序。
2. Java程序中创建对象的常规方式有如下四种：
ü  通过new调用构造器创建java对象。
ü  通过Class对象的newInstance()方法调用构造器创建java对象。
ü  通过java的反序列化机制从IO流中恢复java对象。
ü  通过java对象提供的clone()方法复制一个新的java对象。
3. 对于java程序中的字符直接量，JVM会使用一个字符串池来保存它们：当第一次使用某个字符串直接量时，JVM会将它放入字符串池进行缓存。在一般情况下，字符串池中字符串对象不会被垃圾回收，当程序再次需要使用字符串时，无需重新创建一个新的字符串，而是直接让引用变量指向字符串池中已有的字符串。
4. 关于以直接量的方式来创建java对象的一些问题：
String str1 = "liyafang";
	     String str2 = "liyafang";
	     System.out.println(str1==str2);//true
	     //虽然str4的值不是直接量，但因为它的值可以在编译时确定，
	     //所以str4也会直接引用字符串池中对应的字符串。
	     String str3 = "liyafang2";
	     String str4 = "li"+"yafang"+2;//只创建了一个字符串对象
	     System.out.println(str3==str4);//true
	     //str6的值包含了方法调用，不能再编译时确定，所以无法利用JVM的字符串池
	     String str5 = "liyafang8";
	     String str6 = "liyafang"+"liyafang".length();
	     System.out.println(str5==str6);//false
	     //str8的值使用了变量，不能再编译时确定，所以无法利用JVM的字符串池
	     int len = 1;
	     String str7 = "liyafang1";
	     String str8 = "liyafang"+len;
	     System.out.println(str7==str8);//false
	     //字符串连接运算中的所有变量都可执行"宏替换"，
	     //那么JVM一样可以在编译时就确定字符串连接表达式的值
	     final String temp = "li";
	     String str9 = "liyafang";
	     String str10 = temp+"yafang";
	     System.out.println(str9==str10);//true
	     final int leng = 8;
	     String str11 = "liyafang8";
	     String str12 = "liyafang"+leng;
	     System.out.println(str11==str12);//true
 
5.       不可变的字符串：
			String str = "I";
	 		System.out.println(System.identityHashCode(str));
	 		//该静态方法用于获取某个对象唯一的hashCode值，这个方法的返回值与该类是否重写
	 		//hashCode方法无关。只有当两个对象相同时，它们的identityHashCode值才会相等。
	 		str = str+" love ";
	 		System.out.println(System.identityHashCode(str));
	 		str = str+"java!";
	 		System.out.println(System.identityHashCode(str));




运行结果：
31843011
25860399
5184781
看起来str对应的字符串序列可以发生改变。但是要记住，str只是一个引用类型变量，它并不是真正的String对象，只是指向String对象而已，真正发生改变的是str变量本身，它改变了指向，指向了一个新的String对象。以上程序总共会创建3个字符串对象，“I”，“I love ”，“I love java！”，其中前两个将一直存在于字符串常量池中-这就是java内存泄漏的原因之一。
6.优先考虑使用StringBuilder：
其与StringBuffer唯一的区别在于StringBuffer是线程安全的，也就说StringBuffer类里绝大部分方法都增加了synchronized修饰符。在单线程环境下，优先考虑StringBuilder，因其效率高。
7.String类实现了Comparable接口：
可以通过compareTo()方法比较两个字符串之间的大小，当两个字符串所包含的字符序列相等时，返回值为0。比较规则：先将两个字符串左对齐，然后从左向右依次比较两个字符串所包含的每个字符，包含较大字符的字符串的值比较大。
1.2  表达式类型的陷阱
1.表达式类型的自动提升：
byte->short;
short,char->int->long->float->double
eg: short a = 5; a = a -2;此时将会发生错误，因为int赋给short类型的变量将发生错误。
2.复合赋值运算符的陷阱：
    short a = 5; a -=2; 没有错误，根据java语言规范，复合赋值运算符包含了一个隐式的类型转换，所以a-=2等价于a = (a的类型)(a-2);与此类似的有+=，*=，/=,%=,<<=,>>=,>>>=,&=,^=和|=等。
    再看下面这个例子：
             short st = 15;
             st += 90000;
             System.out.println(st);//输出结果不是900015，而是24479
    因为short类型的变量只能接受-32768~32767之间的整数，因此上面程序会将高位“截断”。
    复合赋值运算符简单，方便，而且具有性能上的优势，但复合赋值运算符可能有一定的风险：它潜在的隐式类型转换可能不知不觉中导致计算结果的高位被截断，为了避免潜在的危险，如下情况需要额外注意：
    将复合赋值运算符应用于byte，short，char等类型的变量；应用于int类型的变量，而表达式右边是long，float，double类的值；应用于float类型的变量，而表达式右侧是double类型的值。
    当+用于字符串连接符时，则+=的变量只能是String类型的，而不可是String的父类型（如Object或CharSequence）。
1.3  输入法导致的陷阱
基本上如果在编译java程序时提示形如：“非法字符：\xxxxx”的错误提示，那么就可断定该java程序中包含“全角字符”，逐个删除他们即可。
1.4  注释的字符必须合法
Java要求注释中所有的字符必须是合法的字符。Java程序允许直接使用\uXXXX的形式代表字符，它要求\u后面的4个字符必须是0~F字符，如果注释中出现“\unit5”,这不符合java对Unicode转义字符的要求。
1.5  转义字符的陷阱
Java程序提供三种方式表示字符：
直接使用单引号括起来的字符值，如’a’;
使用转义字符，如’\n’;
使用Unicode转义字符，如’\u0062’。
不过转移字符得慎用，如下：
System.out.println(“abc\u000a”.length());这句话无法通过编译，提示：未结束的字符串字面值。引起这个原因是java对Unicode转移字符不会进行任何特殊的处理，只是简单的将其替换成相应的字符。对于\u000a而言，相当于一个换行符(\n)，因此上边的程序相当于：
System.out.println(“abc
”.length());
这样就不难理解出现的编译错误了。
类似的情况如下边的注释将通不过编译：
//\u000a代表一个换行符。
因为对于java编译器来说相当于
//
代表一个换行符。


1.5  正则表达式的陷阱

以下程序不会输出任何东西，想想为什么？
String str = "www.baidu.com";
                   String[] str1 = str.split(".");
                   for(String s:str1){
                            System.out.println(s);
                   }
从JDK1.4开始，java的String类提供了split()方法进行字符串的分割。JDK1.0原来提供的StringTokenizer基本上已经成为“历史遗物”了。
对于上面的程序，需要注意两点：
1.String提供的split(String regex)方法需要的参数是正则表达式；
2.正则表达式中的点号(“.”)可以匹配任意字符。
所以上面程序实际上不是以“.”作为分隔符，而是以任意字符作为分隔符。为了实现以“.”作为分隔符的目的，必须对“.”号进行转义，将上面的程序改为
String[] str1 = str.split("\\.");即可得到想要的结果。
从JDK1.4开始，Java加入了对正则表达式的支持，String类也增加了一些方法用于支持正则表达式，具体方法如下：
matches(String regex):判断该字符串是否匹配指定正则表达式。
String replaceAll(String regex,Stringreplacement):将字符串中所有匹配指定正则表达式的子串替换成replacement后返回。
String replaceFirst(String regex,Stringreplacement):将字符串中第一个匹配正则表达式的子串替换成replacement后返回。
String[] split(String regex):以regex正则表达式匹配的子串作为分割符来分割该字符串。
replace(CharSequence target,CharSequencereplacement):将字符串中所有target子串替换成replacement后返回。这个普通的replace()方法不支持正则表达式，开发中必须区别对待replaceAll和replace两个方法。
例如：
                   String str = "www.baidu.com";
                   String str1 = str.replace(".", "\\");
                   String str2 = str.replaceAll("\\.", "\\\\");
                   System.out.println(str1);//输出结果：www\baidu\com
                   System.out.println(str2);//输出结果：www\baidu\com