------------------------------String在内存中的存储情况(一下内容摘自参考资料1)-----------------------------------
前提:先了解下什么是声明,什么时候才算是产生了对象实例
一、首先看看Java虚拟机JVM的内存块及其变量、对象内存空间是怎么存储分配的
1、栈:存放基本数据类型及对象变量的引用,对象本身不存放于栈中而是存放于堆中
1)、基础类型 byte (8位)、boolean (1位)、char (16位)、int (32位)、short (16位)、float (32位)、double (64位)、long (64位)
2)、java代码作用域中定义一个变量时,则java就在栈中为这个变量分配内存空间,当该变量退出该作用域时,java会自动释放该 变量所占的空间
2、堆:new操作符的对象
1)、new创建的对象和数组
2)、在堆中分配的内存,由Java虚拟机的自动垃圾回收器来管理
3、静态域:static定义的静态成员变量
4、常量池:存放常量
二、Java String类型
Java中String不是基本数据类型,而是一种特殊的类。String代表的是不可变的字符序列,为不可变对象,一旦被创建,就不能修改它的值,对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去
三 、String实例代码分析
package terry.java.base;
public class StringTest {
public static void main(String[] args) {
String a = "hello";
String b = "hello";
String newA = new String("hello");
String newB = new String("hello");
System.out.println("****** Testing Object == ******");
System.out.println("a==b ? :" + (a==b));
System.out.println("newA==newB ? :" +(newA==newB));
System.out.println("a==newA ? :" + (a==newA));
System.out.println("***** Testing String Object intern method******");
System.out.println("a.intern()==b.intern() ? : " + (a.intern()==b.intern()));
System.out.println("newA.intern()==newB.intern() ? :" + (newA.intern()==newB.intern()));
System.out.println("a.intern()==newA.intern() ? :" + (a.intern()==newA.intern()));
System.out.println("a=a.intern() ? :" + (a==a.intern()));
System.out.println("newA==newA.intern() ? : " + (newA==newA.intern()));
System.out.println("****** Testing String Object equals method******");
System.out.println("equals() method :" + a.equals(newA));
String c = "hel";
String d = "lo";
final String finalc = "hel";
final String finalgetc = getc();
System.out.println("****** Testing Object splice ******");
System.out.println("a==\"hel\"+\"lo\" ? :" + (a=="hel"+"lo"));
System.out.println("a==c+d ? : " + (a==c+d));
System.out.println("a==c+\"lo\" ? : " + (a==c+"lo"));
System.out.println("a==finalc+\"lo\" ? :" + (a==finalc+"lo"));
System.out.println("a==finalgetc+\"lo\" ? :" + (a==finalgetc+"lo"));
}
private static String getc(){
return "hel";
}
}
Run As Java Application -- 输出结果:
****** Testing Object == ******
a==b ? :true
newA==newB ? :false
a==newA ? :false
***** Testing String Object intern method******
a.intern()==b.intern() ? : true
newA.intern()==newB.intern() ? :true
a.intern()==newA.intern() ? :true
a==a.intern() ? :true
newA==newA.intern() ? : false
****** Testing String Object equals method******
equals() method :true
****** Testing Object splice ******
a=="hel"+"lo" ? :true
a==c+d ? : false
a==c+"lo" ? : false
a==finalc+"lo" ? :true
a==finalgetc+"lo" ? :false
内存分析:
上述各个变量及引用在JVM分配的内存情况
String类型对象实例直接赋值和new操作符产生的结果在JVM内存分配过程是不同的,如下注释说明
String常量+的拼接 及 String常量与引用实例+的拼接 的区别
关于String对象的intern()方法的说明
一个初始时为空的字符串池,它由类 String
私有地维护
当调用 intern 方法时,如果池已经包含一个等于此 String
对象的字符串(该对象由 equals(Object)
方法确定),则返回池中的字符串。否则,将此String
对象添加到池中,并且返回此String
对象的引用,因此a.intern(),b.intern(),newA.intern(),newB.intern()隐含的各自在栈中分配了各自的内存区域,同时都将栈中的应用全部指向了String pool常量池中的同一块区域"hello"
来看下String的源代码:
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */汉化一下:这个value是用来装char的.明白了吧,String其实是char数组的包装类。
//而这个数组是final类型的,不可能指向别的对象,但是可以改,这个请耐心看下去
private final char value[];
/** Cache the hash code for the string */缓存hashCode
private int hash; // Default to 0
}
源码中String的本质是一个final类型的char数组,既然是final类型,那个该数组引用value就不允许再指向其他对象了,因此只从类的设计角度讲:如果jdk源码中并没有提供对value本身的修改,那么理论上来讲String是不可变的。
StringBuilder的故事
大家都知道String的有两个关系很亲近的小伙伴:StringBuffer、StringBuilder,其中的区别大家可以看源代码,StringBuffer对每个方法(除了构造函数)都用了同步,StringBuilder就内向多了。
大家还知道java中是不支持运算符重载的,但是有且仅有两个例外:+、+=对String进行的重载。
+、+=被重载了,+用来连接String操作:就是说 “a" + "b" + ”c“= ”abc“;
上文书说道:
String是不可变的,即是说String a = "a" ; a + "b" 之后,a还是”a“,这个”ab“实际上又生成了一个新的String对象。将这个赋值语句剖析一下:
"a" + "b" + "c":先计算前两个 "a" + "b":这时内存中其实有四个字符串,”a“,"b","c","ab",然后再+”c“,这是内存中有五个String:”a“,"b","c","ab",”abc“。
真的是这样吗?
可以通过javap来反编译上面的赋值语句,会发现,在编译本条语句时,编译器会自作主张的引入了StringBuilder,并调用了StringBuilder.append方法,这样就不用再生成多余的字符串了;
因此在用StringBuilder进行append操作时候,千万不要使用append("a" + "b")这样的操作,因为酱,编译器会为你另外的创建一个StringBuilder对象来处理括号里的字符串操作。
toString的故事,无意识的递归:
toString方法里面谨慎返回this,可能因此无限递归;
this遇到+“”时候,会将this转换成String,怎么转换呢?通过调用toString方法的好了,无限递归,栈溢出。
String真的不可变吗?
从上文可知String的成员变量是private final 的,也就是初始化之后不可改变。那么在这几个成员中, value比较特殊,因为他是一个引用变量,而不是真正的对象。value是final修饰的,也就是说final不能再指向其他数组对象,那么我能改变value指向的数组吗? 比如将数组中的某个位置上的字符变为下划线“_”。 至少在我们自己写的普通代码中不能够做到,因为我们根本不能够访问到这个value引用,更不能通过这个引用去修改数组。 那么用什么方式可以访问私有成员呢? 没错,用反射, 可以反射出String对象中的value属性, 进而改变通过获得的value引用改变数组的结构。下面是实例代码:
//创建字符串"Hello World", 并赋给引用s
String s = "Hello World";
System.out.println("s = " + s); //Hello World
//获取String类中的value字段
Field valueFieldOfString = String.class.getDeclaredField("value");
//改变value属性的访问权限
valueFieldOfString.setAccessible(true);
//获取s对象上的value属性的值
char[] value = (char[]) valueFieldOfString.get(s);
//改变value所引用的数组中的第5个字符
value[5] = '_';
System.out.println("s = " + s); //Hello_World
}
打印结果为: s = Hello World
s = Hello_World
在这个过程中,s始终引用的同一个String对象,但是再反射前后,这个String对象发生了变化, 也就是说,通过反射是可以修改所谓的“不可变”对象的。但是一般我们不这么做。这个反射的实例还可以说明一个问题:如果一个对象,他组合的其他对象的状态是可以改变的,那么这个对象很可能不是不可变对象。例如一个Car对象,它组合了一个Wheel对象,虽然这个Wheel对象声明成了private final 的,但是这个Wheel对象内部的状态可以改变, 那么就不能很好的保证Car对象不可变。
常用方法:
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringndexOutOfBoundsException(index);
}
return value[index];//先判断越界,然后直接返回合法值
}
public boolean isEmpty() {
return value.length == 0;
}
public boolean contentEquals(StringBuffer sb) {
synchronized (sb) {
return contentEquals((CharSequence) sb);
}
}
public boolean contentEquals(CharSequence cs) {
if (value.length != cs.length())
return false;
// Argument is a StringBuffer, StringBuilder
if (cs instanceof AbstractStringBuilder) {
char v1[] = value;
char v2[] = ((AbstractStringBuilder) cs).getValue();
int i = 0;
int n = value.length;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
// Argument is a String
if (cs.equals(this))
return true;
// Argument is a generic CharSequence
char v1[] = value;
int i = 0;
int n = value.length;
while (n-- != 0) {
if (v1[i] != cs.charAt(i))
return false;
i++;
}
return true;
}
contentEquals(CharSequence cs)
contentEquals(charSequence cs)参数可以是StringBuilder、StringBuffer、String以及CharSequence,contentEquals(StringBuilder sb)只是为了保证sb的一致性,在外面加了互斥锁。equals方法也只是contentEquals的一种情况的实现,完全可以用contentEquals(cs)来取代。
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
return new String(buf, true);//返回了新的string
}
concat(String str)
concat方法可以看出,最后返回的其实是一个新new的string。并不对原value内容进行改动。
同样的:
public String substring(int beginIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}
substring
这两个方法很好用
public boolean startsWith(String prefix, int toffset) {
char ta[] = value;
int to = toffset;
char pa[] = prefix.value;
int po = 0;
int pc = prefix.value.length;
// Note: toffset might be near -1>>>1.
if ((toffset < 0) || (toffset > value.length - pc)) {
return false;
}
while (--pc >= 0) {
if (ta[to++] != pa[po++]) {
return false;
}
}
return true;
}
startsWith
public boolean endsWith(String suffix) {
return startsWith(suffix, value.length - suffix.value.length);
}
endsWith是用startsWith实现的,只看名字有点搞笑。
原文:http://www.cnblogs.com/huntfor/p/3909059.html?utm_source=tuicool&utm_medium=referral