java中String和new String还有对象中的String字符串在内存中的存储

 参考自：http://blog.csdn.net/zhangjg_blog/article/details/18319521 的博客，很多知识和代码都来源此，感兴趣的同学可以去看看

    一直以来，所有人都说，java中的String类型是不可变的，可是为什么不可变确很少有人说的透彻，String和new String的区别，对象中的String和直接定义一个String是否有区别，一直都是一知半解。看了很多文档都是各种猜测，没有具体代码来证明。今天看了上面的博客做了一些测试，有一些心得。String类型一直是一个特殊的数据类型，在创建的时候就是不可变的，会在Stringconstant pool中创建一个常量，当我们再次创建一个字符串的时候，jvm会先去String constant pool 中检索这个这个常量是否存在，如果存在则将引用返回，如果不存在，则创建新的常量，然后将引用返回。那么使用new String的方法创建？或者是在一个对象的实例中创建一个字符串？内存中这个值会如何存储？是在Heap中直接开辟空间存储，还是会在Stringconstant pool 中创建，然后在Heap中创建一个引用？接下来，通过代码来证明，在内存中String究竟是如何存储的

   首先是String和new String的区别

	public static void main(String[] args) throws Exception {
		String hello="hello world";
		String xx=new String("hello world");
		String yy="hello world";
		
		//输出判断内存地址是否相等
		System.out.println("xx==hello : "+ (xx==hello));
		System.out.println("yy==hello : "+ (yy==hello)+"\n");
		
		//通过反射修改hello的value值
		Field hello_field=String.class.getDeclaredField("value");
		hello_field.setAccessible(true);
		char[] value=(char[])hello_field.get(hello);
		value[5]='_';
		
		//首先输出修改结果
		System.out.println("Hello: "+hello+"\n");
		
		//然后判断内存地址是否有变化
		System.out.println("xx==hello : "+ (xx==hello));
		System.out.println("yy==hello:"+(hello==yy));
		System.out.println("xx==yy:"+(xx==yy)+"\n"); 
		
		//最后输出所有值的结果
		System.out.println("xx: "+xx);
		System.out.println("yy: "+yy);
		System.out.println("Hello: "+hello);
	}

 代码执行结果

xx==hello : false
yy==hello : true

Hello: hello_world

xx==hello : false
yy==hello:true
xx==yy:false

xx: hello_world
yy: hello_world
Hello: hello_world

 根据结果可以判断，无论是String还是new String最终都指向了String constant pool中，只不过是String直接指向了Stringconstant pool中。而new String是在Heap中创建了一个指向String constant pool中的引用。那么，对象中String是否也是这样的？那么我们是否可以这样推测，在java中所有的String类型的字符串，最终都会指向Stringconstant pool  中？

  然后是String和Object的区别

import java.lang.reflect.Field;

public class StringTest {

	public String name="hello world"; 
	
	public String phone; 
	
	public StringTest(String phone) {
		// TODO Auto-generated constructor stub
		this.phone=phone;
	}
	
	public static void main(String[] args) throws Exception {
		StringTest a = new StringTest("hello world");
		StringTest b = new StringTest("hello world");
		String c = "hello world";
		String e = new String("hello world");
		
		//首先判断不同对象中的字符串地址是否相等
		System.out.println("a.name==a.phone:"+(a.name==a.phone));
		System.out.println("a.name==b.phone:"+(a.name==b.phone));
		System.out.println("a.name==c:"+(a.name==c));
		System.out.println("e==c:"+(e==c)+"\n");
		
		//然后修改c在内存中的值
		Field hello_field=String.class.getDeclaredField("value");
		hello_field.setAccessible(true);
		char[] value=(char[])hello_field.get(c);
		value[5]='_';
		
		//首先判断不同对象中的字符串地址是否相等
		System.out.println("a.name==a.phone:"+(a.name==a.phone));
		System.out.println("a.name==b.phone:"+(a.name==b.phone));
		System.out.println("a.name==c:"+(a.name==c));
		System.out.println("e==c:"+(e==c)+"\n");
		
		//直接输出值判断是否发生变化
		System.out.println("a.name: "+a.name);
		System.out.println("b.name: "+b.name);
		System.out.println("a.phone: "+a.phone);
		System.out.println("b.phone: "+b.phone);
		System.out.println("c: "+c);
		System.out.println("e: "+e);
	}
	
}

 代码执行结果

a.name==a.phone:true
a.name==b.phone:true
a.name==c:true
e==c:false

a.name==a.phone:true
a.name==b.phone:true
a.name==c:true
e==c:false

a.name: hello_world
b.name: hello_world
a.phone: hello_world
b.phone: hello_world
c: hello_world
e: hello_world

  根据执行结果可以看出，不同对象中的String值相等时，其指向的是同一个String constant pool中的地址，如果我们修改了其中一个值得时候，所有的引用都会发生改变，而且其内存地址的比较并没有发生变化。所以我们的推测应该是正确的，因时间关系，没有了测试数组和其他的关于String类型的字符串是否也是如此，不过根据上面的结果，我们应该可以大胆猜测，java中，如果定义了String类型的字符串，最终的都存在String constant pool 中。如果有什么意见或建议请在下方留言，再次感谢原博主