「Java基本功」一文读懂String及其包装类的实现原理

打开凤凰新闻,查看更多高清图片

String作为Java中最常用的引用类型,相对来说基本上都比较熟悉,无论在平时的编码过程中还是在笔试面试中,String都很受到青睐,然而,在使用String过程中,又有较多需要注意的细节之处。

String的连接

@Test

publicvoid contact () {

   //1连接方式

   String s1 = "a";

   String s2 = "a";

   String s3 = "a" + s2;

   String s4 = "a" + "a";

   String s5 = s1 + s2;

   //表达式只有常量时,编译期完成计算

   //表达式有变量时,运行期才计算,所以地址不一样

   System.out.println(s3 == s4); //f

   System.out.println(s3 == s5); //f

   System.out.println(s4 == "aa"); //t

}

String类型的intern

publicvoid intern () {    //2:string的intern使用    //s1是基本类型,比较值。s2是string实例,比较实例地址    //字符串类型用equals方法比较时只会比较值    String s1 = "a";    String s2 = newString("a");    //调用intern时,如果s2中的字符不在常量池,则加入常量池并返回常量的引用    String s3 = s2.intern();    System.out.println(s1 == s2);    System.out.println(s1 == s3);}

String类型的equals

//字符串的equals方法//    public boolean equals(Object anObject) {//            if (this == anObject) {//                return true;//            }//            if (anObject instanceof String) {//                String anotherString = (String)anObject;//                int n = value.length;//                if (n == anotherString.value.length) {//                    char v1[] = value;//                    char v2[] = anotherString.value;//                    int i = 0;//                    while (n-- != 0) {//                        if (v1[i] != v2[i])//                            return false;//                        i++;//                    }//                    return true;//                }//            }//            return false;//        }

StringBuffer和Stringbuilder

底层是继承父类的可变字符数组value

/**

* The value is used for character storage.

*/

char[] value;

初始化容量为16

/**

* Constructs a string builder with no characters in it and an

* initial capacity of 16 characters.

*/

publicStringBuilder() {

   super(16);

}

这两个类的append方法都是来自父类AbstractStringBuilder的方法

publicAbstractStringBuilder append(String str) {

   if (str == null)

       return appendNull();

   int len = str.length();

   ensureCapacityInternal(count + len);

   str.getChars(0, len, value, count);

   count += len;

   returnthis;

}

@Override

publicStringBuilder append(String str) {

   super.append(str);

   returnthis;

}

@Override

publicsynchronizedStringBuffer append(String str) {

   toStringCache = null;

   super.append(str);

   returnthis;

}

append

Stringbuffer在大部分涉及字符串修改的操作上加了synchronized关键字来保证线程安全,效率较低。

String类型在使用 + 运算符例如

String a = "a"

a = a + a;时,实际上先把a封装成stringbuilder,调用append方法后再用tostring返回,所以当大量使用字符串加法时,会大量地生成stringbuilder实例,这是十分浪费的,这种时候应该用stringbuilder来代替string。

扩容

#注意在append方法中调用到了一个函数

ensureCapacityInternal(count + len);

该方法是计算append之后的空间是否足够,不足的话需要进行扩容

publicvoid ensureCapacity(int minimumCapacity) {

   if (minimumCapacity > 0)

       ensureCapacityInternal(minimumCapacity);

}

privatevoid ensureCapacityInternal(int minimumCapacity) {

   // overflow-conscious code

   if (minimumCapacity - value.length > 0) {

       value = Arrays.copyOf(value,

               newCapacity(minimumCapacity));

   }

}

如果新字符串长度大于value数组长度则进行扩容

扩容后的长度一般为原来的两倍 + 2;

假如扩容后的长度超过了jvm支持的最大数组长度MAX_ARRAY_SIZE。

考虑两种情况

如果新的字符串长度超过int最大值,则抛出异常,否则直接使用数组最大长度作为新数组的长度。

privateint hugeCapacity(int minCapacity) {

   if (Integer.MAX_VALUE - minCapacity < 0) { // overflow

       thrownewOutOfMemoryError();

   }

   return (minCapacity > MAX_ARRAY_SIZE)

       ? minCapacity : MAX_ARRAY_SIZE;

}

删除

这两个类型的删除操作:

都是调用父类的delete方法进行删除

publicAbstractStringBuilderdelete(int start, intend) {

   if (start < 0)

       thrownewStringIndexOutOfBoundsException(start);

   if (end > count)

       end = count;

   if (start > end)

       thrownewStringIndexOutOfBoundsException();

   int len = end - start;

   if (len > 0) {

       System.arraycopy(value, start+len, value, start, count-end);

       count -= len;

   }

   returnthis;

}

事实上是将剩余的字符重新拷贝到字符数组value。

这里用到了system.arraycopy来拷贝数组,速度是比较快的

system.arraycopy方法

转自知乎:

在主流高性能的JVM上(HotSpot VM系、IBM J9 VM系、JRockit系等等),可以认为System.arraycopy()在拷贝数组时是可靠高效的——如果发现不够高效的情况,请报告performance bug,肯定很快就会得到改进。

java.lang.System.arraycopy()方法在Java代码里声明为一个native方法。所以最naïve的实现方式就是通过JNI调用JVM里的native代码来实现。

String的不可变性

关于String的不可变性,这里转一个不错的回答

什么是不可变?

String不可变很简单,如下图,给一个已有字符串"abcd"第二次赋值成"abcedl",不是在原内存地址上修改数据,而是重新指向一个新对象,新地址。

String为什么不可变?

翻开JDK源码,java.lang.String类起手前三行,是这样写的:

publicfinalclassStringimplements java.io.Serializable, Comparable, CharSequence {     /** String本质是个char数组. 而且用final关键字修饰.*/     privatefinalchar value[];  ...  ... }

首先String类是用final关键字修饰,这说明String不可继承。再看下面,String类的主力成员字段value是个char[]数组,而且是用final修饰的。

final修饰的字段创建以后就不可改变。 有的人以为故事就这样完了,其实没有。因为虽然value是不可变,也只是value这个引用地址不可变。挡不住Array数组是可变的事实。

Array的数据结构看下图。

也就是说Array变量只是stack上的一个引用,数组的本体结构在heap堆。

String类里的value用final修饰,只是说stack里的这个叫value的引用地址不可变。没有说堆里array本身数据不可变。看下面这个例子,

finalint[] value={1,2,3} ;

int[] another={4,5,6};

value=another;    //编译器报错,final不可变 value用final修饰,编译器不允许我把value指向堆区另一个地址。

但如果我直接对数组元素动手,分分钟搞定。

finalint[] value={1,2,3};

value[2]=100;  //这时候数组里已经是{1,2,100}   所以String是不可变,关键是因为SUN公司的工程师。

在后面所有String的方法里很小心的没有去动Array里的元素,没有暴露内部成员字段。

privatefinalchar value[]这一句里,private的私有访问权限的作用都比final大。而且设计师还很小心地把整个String设成final禁止继承,避免被其他人继承后破坏。所以String是不可变的关键都在底层的实现,而不是一个final。考验的是工程师构造数据类型,封装数据的功力。

不可变有什么好处?

这个最简单地原因,就是为了安全。看下面这个场景(有评论反应例子不够清楚,现在完整地写出来),一个函数appendStr( )在不可变的String参数后面加上一段“bbb”后返回。appendSb( )负责在可变的StringBuilder后面加“bbb”。

总结以下String的不可变性。

1 首先final修饰的类只保证不能被继承,并且该类的对象在堆内存中的地址不会被改变。

2 但是持有String对象的引用本身是可以改变的,比如他可以指向其他的对象。

3 final修饰的char数组保证了char数组的引用不可变。但是可以通过char[0] = a来修改值。不过String内部并不提供方法来完成这一操作,所以String的不可变也是基于代码封装和访问控制的。

举个例子

finalclassFi {

   int a;

   finalint b = 0;

   Integer s;

}

finalchar[]a = {a};

finalint[]b = {1};

@Test

publicvoidfinal修饰类() {

   //引用没有被final修饰,所以是可变的。

   //final只修饰了Fi类型,即Fi实例化的对象在堆中内存地址是不可变的。

   //虽然内存地址不可变,但是可以对内部的数据做改变。

   Fi f = newFi();

   f.a = 1;

   System.out.println(f);

   f.a = 2;

   System.out.println(f);

   //改变实例中的值并不改变内存地址。

   Fi ff = f;

   //让引用指向新的Fi对象,原来的f对象由新的引用ff持有。

   //引用的指向改变也不会改变原来对象的地址

   f = newFi();

   System.out.println(f);

   System.out.println(ff);

}

这里的对f.a的修改可以理解为char[0] = a这样的操作。只改变数据值,不改变内存值。

要理解String里的intern方法,就要注意基本数据类型的拆箱装箱,以及对常量池的理解。

常量池和自动拆箱装箱

自动拆箱和装箱的原理其实与常量池有关。

3.1存在栈中:

publicvoid(int a)

{

int i = 1;

int j = 1;

}

方法中的i 存在虚拟机栈的局部变量表里,i是一个引用,j也是一个引用,它们都指向局部变量表里的整型值 1.

int a是传值引用,所以a也会存在局部变量表。

3.2存在堆里:

class A{

int i = 1;

A a = new A();

}

i是类的成员变量。类实例化的对象存在堆中,所以成员变量也存在堆中,引用a存的是对象的地址,引用i存的是值,这个值1也会存在堆中。可以理解为引用i指向了这个值1。也可以理解为i就是1.

3.3包装类对象怎么存

其实我们说的常量池也可以叫对象池。

比如String a= newString("a").intern()时会先在常量池找是否有“a"对象如果有的话直接返回“a"对象在常量池的地址,即让引用a指向常量”a"对象的内存地址。

public native String intern();

Integer也是同理。

下图是Integer类型在常量池中查找同值对象的方法。

publicstaticInteger valueOf(int i) {

   if (i >= IntegerCache.low && i <= IntegerCache.high)

       returnIntegerCache.cache[i + (-IntegerCache.low)];

   returnnewInteger(i);

}

privatestaticclassIntegerCache {

   staticfinalint low = -128;

   staticfinalint high;

   staticfinalInteger cache[];

   static {

       // high value may be configured by property

       int h = 127;

       String integerCacheHighPropValue =

           sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");

       if (integerCacheHighPropValue != null) {

           try {

               int i = parseInt(integerCacheHighPropValue);

               i = Math.max(i, 127);

               // Maximum array size is Integer.MAX_VALUE

               h = Math.min(i, Integer.MAX_VALUE - (-low) -1);

           } catch( NumberFormatException nfe) {

               // If the property cannot be parsed into an int, ignore it.

           }

       }

       high = h;

       cache = newInteger[(high - low) + 1];

       int j = low;

       for(int k = 0; k < cache.length; k++)

           cache[k] = newInteger(j++);

       // range [-128, 127] must be interned (JLS7 5.1.7)

       assertIntegerCache.high >= 127;

   }

   privateIntegerCache() {}

}

所以基本数据类型的包装类型可以在常量池查找对应值的对象,找不到就会自动在常量池创建该值的对象。

而String类型可以通过intern来完成这个操作。

JDK1.7后,常量池被放入到堆空间中,这导致intern()函数的功能不同,具体怎么个不同法,且看看下面代码,这个例子是网上流传较广的一个例子,分析图也是直接粘贴过来的,这里我会用自己的理解去解释这个例子:

[java] view plain copy

String s = newString("1");  

s.intern();  

String s2 = "1";  

System.out.println(s == s2);  

String s3 = newString("1") + newString("1");  

s3.intern();  

String s4 = "11";  

System.out.println(s3 == s4);  

输出结果为:

[java] view plain copy

JDK1.6以及以下:falsefalse  

JDK1.7以及以上:falsetrue

JDK1.6查找到常量池存在相同值的对象时会直接返回该对象的地址。

JDK 1.7后,intern方法还是会先去查询常量池中是否有已经存在,如果存在,则返回常量池中的引用,这一点与之前没有区别,区别在于,如果在常量池找不到对应的字符串,则不会再将字符串拷贝到常量池,而只是在常量池中生成一个对原字符串的引用。

那么其他字符串在常量池找值时就会返回另一个堆中对象的地址。