java中string详解

String的特性：

String是个final类型的对象。因此对于String变量一旦初始化，那么我们是不能对它的值进行操作的，但是它的指向是可以改变的。就是说他可以抛弃当前对象，指向其他对象，那么当前对象就孤立了，成为了游离对象。

一般不用string对象来做累加，因为会产生很多中间对象，浪费空间。（因为每加一次之前的这些对象成为了游离对象，相当于是没用了，但是还是占用内存空间）

String的多种初始化比较和讲解：

package testJava;

public class testjava {
	
	public static void main(String[] args) {  
		
	        /** 
	         * 情景一：字符串池 
	         * JAVA虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象; 
	         * 并且可以被共享使用，因此它提高了效率。 
	         * 由于String类是final的，它的值一经创建就不可改变。 
	         * 字符串池由String类维护，我们可以调用intern()方法来访问字符串池。  
	         */  
			// 在字符串池创建了一个对象  
	        String s1 = "abc";     
	        // 字符串pool已经存在对象“abc”(共享),所以不会创建新对象，s2直接指向池中的abc 
	        String s2 = "abc";     
	        // true 指向同一个对象  
	        System.out.println("s1 == s2 : "+(s1==s2));    
	        // true  值相等  
	        System.out.println("s1.equals(s2) : " + (s1.equals(s2)));    
	        
	        
	        /** 
	         * 情景二：
	         * 关于new String(""),只要使用了new就会在堆中创建新的对象
	         *  
	         */ 
	        //在堆中创建了一个新的对象，s3指向该对象
	        String s3 = new String("abc");  
	        //在堆中重新创建了一个新的对象，s4指向新对象
	        String s4 = new String("abc");  
	        //s3和s4栈区的地址不同，指向堆区的不同地址  false
	        System.out.println("s3 == s4 : "+(s3==s4));  
	        //s3和s4的值相同   true
	        System.out.println("s3.equals(s4) : "+(s3.equals(s4)));  
	        //false 存放的地区都不同，一个字符串池中，一个堆区  
	        System.out.println("s1 == s3 : "+(s1==s3));  
	        //true  值相同  
	        System.out.println("s1.equals(s3) : "+(s1.equals(s3)));  
	        
	        
	        /** 
	         * 情景三：  
	         * 由于常量的值在编译的时候就被确定(优化)了。 
	         * 在这里，"ab"和"cd"都是常量，因此变量str3的值在编译时就可以确定。 
	         * 这行代码编译后的效果等同于： String str3 = "abcd"; 
	         */  
	        String str1 = "ab" + "cd";  //1个对象  
	        String str11 = "abcd";  
	        /**
	         * 因为str1的时候在字符串池中已经 有了ab，cd，abcd,当str11时首先去
	         * 查询池中是否有该字符串，发现有后直接将adcd的引用给str11
	         */
	        //true
	        System.out.println("str1 = str11 : "+ (str1 == str11));  
	        
	        
	        /** 
	         * 情景四(特别注意)：  
	         *  
	         * 第三行代码原理(str2+str3)： 
	         * 运行期JVM首先会在堆中创建一个StringBuilder类， 
	         * 同时用str2指向的字符串对象完成初始化， 
	         * 然后调用append方法完成对str3所指向的字符串的合并， 
	         * 接着调用StringBuilder的toString()方法在堆中创建一个String对象， 
	         * 最后将刚生成的String对象的堆地址存放在局部变量str4中。 
	         *  
	         * 而str5存储的是字符串池中"abcd"所对应的拘留字符串对象的地址。 
	         * str4与str5地址当然不一样了。 
	         *  
	         * 内存中实际上有五个字符串对象： 
	         *  三个字符串池对象、一个String对象和一个StringBuilder对象。 
	         */  
	        String str2 = "ab";  //1个对象  
	        String str3 = "cd";  //1个对象                                         
	        String str4 = str2+str3;   //str2.append(str3) 新对象                                     
	        String str5 = "abcd";    
	        System.out.println("str4 = str5 : " + (str4==str5)); // false  
	        
	        
	        /** 
	         * 情景五(注意区分4和5的异同)： 
	         *  JAVA编译器对string + 基本类型/常量 是当成常量表达式直接求值来优化的。 
	         *  运行期的两个string相加，会产生新的对象的，存储在堆(heap)中 
	         */  
	        String str6 = "b";  
	        String str7 = "a" + str6;  //新对象，存放堆中
	        String str67 = "ab"; 
	        //str6为变量，在运行期才会被解析。  
	        System.out.println("str7 = str67 : "+ (str7 == str67));  //false 
	        //有final修饰表示为常量(区分str6和str8)
	        final String str8 = "b";  
	        String str9 = "a" + str8;  
	        String str89 = "ab";  
	        //str8为常量变量，编译期会被优化   
	        System.out.println("str9 = str89 : "+ (str9 == str89));  //true
	       
	        
	    }
}

String几种构造函数的方式：

String s=new String("We are students!");   //直接构造

Stirng s="We are boys";        String str=new String(s);  //用已用对象构造

char[] a={'b ','o'.'y'};         String s=new String (a);  //用字符数组构造

String类的方法（具体方法网上一大堆，不一一列举）：

String本身操作的一些方法

String和字符串数组的转换的方法

String和字节数组转换的方法

String重写了Object的hashcode和equals方法。一般我们对字符串进行比较：如果有常量的话，我们最好把常量字符串写在前面，这样可以避免空指针异常。例："chenlu".trim().equals(str)。

注：equals和==的区别，equals表示比较字符串内容是否相等，==表示比较引用是否相等，即对象的指向--地址。