Java基础3：深入理解String及包装类
本节主要介绍字符串常量和字符串类型的区别
String的连接：
1 @Test 2 public void contact () { 3 //1连接方式 4 String s1 = "a"; 5 String s2 = "a"; 6 String s3 = "a" + s2; 7 String s4 = "a" + "a"; 8 String s5 = s1 + s2; 9 //表达式只有常量时，编译期完成计算 10 //表达式有变量时，运行期才计算，所以地址不一样 11 System.out.println(s3 == s4); //f 12 System.out.println(s3 == s5); //f 13 System.out.println(s4 == "aa"); //t 14 15 }
String类型的intern：
1 public void intern () { 2 //2：string的intern使用 3 //s1是基本类型，比较值。s2是string实例，比较实例地址 4 //字符串类型用equals方法比较时只会比较值 5 String s1 = "a"; 6 String s2 = new String("a"); 7 //调用intern时,如果s2中的字符不在常量池，则加入常量池并返回常量的引用 8 String s3 = s2.intern(); 9 System.out.println(s1 == s2); 10 System.out.println(s1 == s3); 11 }
String类型的equals：
1 //字符串的equals方法 2 // public boolean equals(Object anObject) { 3 // if (this == anObject) { 4 // return true; 5 // } 6 // if (anObject instanceof String) { 7 // String anotherString = (String)anObject; 8 // int n = value.length; 9 // if (n == anotherString.value.length) { 10 // char v1[] = value; 11 // char v2[] = anotherString.value; 12 // int i = 0; 13 // while (n-- != 0) { 14 // if (v1[i] != v2[i]) 15 // return false; 16 // i++; 17 // } 18 // return true; 19 // } 20 // } 21 // return false; 22 // }
StringBuffer和Stringbuilder
底层是继承父类的可变字符数组value：
1 /** 2 * The value is used for character storage. 3 */ 4 char[] value; 5 初始化容量为16 6 7 /** 8 * Constructs a string builder with no characters in it and an 9 * initial capacity of 16 characters. 10 */ 11 public StringBuilder() { 12 super(16); 13 } 14 这两个类的append方法都是来自父类AbstractStringBuilder的方法 15 16 public AbstractStringBuilder append(String str) { 17 if (str == null) 18 return appendNull(); 19 int len = str.length(); 20 ensureCapacityInternal(count + len); 21 str.getChars(0, len, value, count); 22 count += len; 23 return this; 24 } 25 @Override 26 public StringBuilder append(String str) { 27 super.append(str); 28 return this; 29 } 30 31 @Override 32 public synchronized StringBuffer append(String str) { 33 toStringCache = null; 34 super.append(str); 35 return this; 36 }
append：
1 Stringbuffer在大部分涉及字符串修改的操作上加了synchronized关键字来保证线程安全，效率较低。 2 3 String类型在使用 + 运算符例如 4 5 String a = "a" 6 7 a = a + a;时，实际上先把a封装成stringbuilder，调用append方法后再用tostring返回，所以当大量使用字符串加法时，会大量地生成stringbuilder实例，这是十分浪费的，这种时候应该用stringbuilder来代替string。
扩容：
1 #注意在append方法中调用到了一个函数 2 3 ensureCapacityInternal(count + len); 4 该方法是计算append之后的空间是否足够，不足的话需要进行扩容 5 6 public void ensureCapacity(int minimumCapacity) { 7 if (minimumCapacity > 0) 8 ensureCapacityInternal(minimumCapacity); 9 } 10 private void ensureCapacityInternal(int minimumCapacity) { 11 // overflow-conscious code 12 if (minimumCapacity - value.length > 0) { 13 value = Arrays.copyOf(value, 14 newCapacity(minimumCapacity)); 15 } 16 } 17 如果新字符串长度大于value数组长度则进行扩容 18 19 扩容后的长度一般为原来的两倍 + 2； 20 21 假如扩容后的长度超过了jvm支持的最大数组长度MAX_ARRAY_SIZE。 22 23 考虑两种情况 24 25 如果新的字符串长度超过int最大值，则抛出异常，否则直接使用数组最大长度作为新数组的长度。 26 27 private int hugeCapacity(int minCapacity) { 28 if (Integer.MAX_VALUE - minCapacity < 0) { // overflow 29 throw new OutOfMemoryError(); 30 } 31 return (minCapacity > MAX_ARRAY_SIZE) 32 ? minCapacity : MAX_ARRAY_SIZE; 33 }
删除：
1 这两个类型的删除操作： 2 3 都是调用父类的delete方法进行删除 4 5 public AbstractStringBuilder delete(int start, int end) { 6 if (start < 0) 7 throw new StringIndexOutOfBoundsException(start); 8 if (end > count) 9 end = count; 10 if (start > end) 11 throw new StringIndexOutOfBoundsException(); 12 int len = end - start; 13 if (len > 0) { 14 System.arraycopy(value, start+len, value, start, count-end); 15 count -= len; 16 } 17 return this; 18 } 19 事实上是将剩余的字符重新拷贝到字符数组value。
这里用到了syastem.arrycopy来拷贝数组，速度是比较快的。
system.arraycopy方法：
1 转自知乎： 2 3 在主流高性能的JVM上（HotSpot VM系、IBM J9 VM系、JRockit系等等），可以认为System.arraycopy()在拷贝数组时是可靠高效的——如果发现不够高效的情况，请报告performance bug，肯定很快就会得到改进。 4 5 java.lang.System.arraycopy()方法在Java代码里声明为一个native方法。所以最naïve的实现方式就是通过JNI调用JVM里的native代码来实现。
String的不可变性：
什么是不可变？
String不可变很简单，给一个已有字符串“abcd”第二次赋值成“abcedl”，不是在原内存地址上修改数据，而是重新指向一个新对象，新地址。
String为什么不可变？
JDK源码中 java,lang.String类起手前三行是这样写的：
1 public final class String implements java.io.Serializable, Comparable<String>, CharSequence { 2 /** String本质是个char数组. 而且用final关键字修饰.*/ 3 private final char value[]; ... ... 4 }
首先String类是用final关键字修饰，这说明String不可继承。再看下面，String类的主力成员字段value是个char[]数组，而且是用final修饰的。
final修饰的字段创建以后就不可改变。 有的人以为故事就这样完了，其实没有。因为虽然value是不可变，也只是value这个引用地址不可变。挡不住Array数组是可变的事实。
Array的数据结构看下图。
final修饰的字段创建以后就不可改变。 有的人以为故事就这样完了，其实没有。因为虽然value是不可变，也只是value这个引用地址不可变。挡不住Array数组是可变的事实。
Array的数据结构看下图。
也就是说Array变量只是stack上的一个引用，数组的本体结构在heap堆。
String类里的value用final修饰，只是说stack里的这个叫value的引用地址不可变。没有说堆里array本身数据不
String类里的value用final修饰，只是说stack里的这个叫value的引用地址不可变。没有说堆里array本身数据不
可变。看下面例子：
1 final int[] value={1,2,3} ； 2 int[] another={4,5,6}; 3 value=another; //编译器报错，final不可变 value用final修饰，编译器不允许我把value指向堆区另一个地址。 4 但如果我直接对数组元素动手，分分钟搞定。 5 6 final int[] value={1,2,3}; 7 value[2]=100; //这时候数组里已经是{1,2,100} 所以String是不可变，关键是因为SUN公司的工程师。 8 在后面所有String的方法里很小心的没有去动Array里的元素，没有暴露内部成员字段。 9 10 private final char value[]这一句里，private的私有访问权限的作用都比final大。而且设计师还很小心地把整个String设成final禁止继承，避免被其他人继承后破坏。所以String是不可变的关键都在底层的实现，而不是一个final。考验的是工程师构造数据类型，封装数据的功力。
不可变有什么好处？
这个最简单地原因，就是为了安全。看下面这个场景（有评论反应例子不够清楚，现在完整地写出来），一个函数appendStr( )在不可变的String参数后面加上一段“bbb”后返回。appendSb( )负责在可变的StringBuilder后面加“bbb”。
总结以下String的不可变性。
1 首先final修饰的类只保证不能被继承，并且该类的对象在堆内存中的地址不会被改变。
2 但是持有String对象的引用本身是可以改变的，比如他可以指向其他的对象。
2 但是持有String对象的引用本身是可以改变的，比如他可以指向其他的对象。
3 final修饰的char数组保证了char数组的引用不可变。但是可以通过char[0] = 'a’来修改值。不过String内部并不提供方法来完成这一操作，所以String的不可变也是基于代码封装和访问控制的。
举个例子：
1 final class Fi { 2 int a; 3 final int b = 0; 4 Integer s; 5 6 } 7 final char[]a = {'a'}; 8 final int[]b = {1}; 9 @Test 10 public void final修饰类() { 11 //引用没有被final修饰，所以是可变的。 12 //final只修饰了Fi类型，即Fi实例化的对象在堆中内存地址是不可变的。 13 //虽然内存地址不可变，但是可以对内部的数据做改变。 14 Fi f = new Fi(); 15 f.a = 1; 16 System.out.println(f); 17 f.a = 2; 18 System.out.println(f); 19 //改变实例中的值并不改变内存地址。 20 21 22 Fi ff = f; 23 //让引用指向新的Fi对象，原来的f对象由新的引用ff持有。 24 //引用的指向改变也不会改变原来对象的地址 25 f = new Fi(); 26 System.out.println(f); 27 System.out.println(ff); 28 } 29 这里的对f.a的修改可以理解为char[0] = 'a'这样的操作。只改变数据值，不改变内存值。
