String的连接 :
@Test
public void 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
public void intern () {
//2:string的intern使用
//s1是基本类型,比较值。s2是string实例,比较实例地址
//字符串类型用equals方法比较时只会比较值
String s1 = "a";
String s2 = new String("a");
//调用intern时,如果s2中的字符不在常量池,则加入常量池并返回常量的引用
String s3 = s2.intern();
System.out.println(s1 == s2); //f
System.out.println(s1 == s3); //t
}
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.
*/
public StringBuilder() {
super(16);
}
//这两个类的append方法都是来自父类AbstractStringBuilder的方法
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
append
Stringbuffer在大部分涉及字符串修改的操作上加了synchronized关键字来保证线程安全,效率较低。
String类型在使用 + 运算符例如
String a = "a"
a = a + a;时,实际上先把a封装成stringbuilder,调用append方法后再用tostring返回,
所以当大量使用字符串加法时,会大量地生成stringbuilder实例,这是十分浪费的,
这种时候应该用stringbuilder来代替string。
扩容
//注意在append方法中调用到了一个函数
ensureCapacityInternal(count + len);
//该方法是计算append之后的空间是否足够,不足的话需要进行扩容
public void ensureCapacity(int minimumCapacity) {
if (minimumCapacity > 0)
ensureCapacityInternal(minimumCapacity);
}
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
/*如果新字符串长度大于value数组长度则进行扩容
扩容后的长度一般为原来的两倍 + 2;
假如扩容后的长度超过了jvm支持的最大数组长度MAX_ARRAY_SIZE。
考虑两种情况
如果新的字符串长度超过int最大值,则抛出异常,否则直接使用数组最大长度作为新数组的长度。*/
private int hugeCapacity(int minCapacity) {
if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
throw new OutOfMemoryError();
}
return (minCapacity > MAX_ARRAY_SIZE)
? minCapacity : MAX_ARRAY_SIZE;
}
删除
这两个类型的删除操作:
都是调用父类的delete方法进行删除
public AbstractStringBuilder delete(int start, int end) {
if (start < 0)
throw new StringIndexOutOfBoundsException(start);
if (end > count)
end = count;
if (start > end)
throw new StringIndexOutOfBoundsException();
int len = end - start;
if (len > 0) {
System.arraycopy(value, start+len, value, start, count-end);
count -= len;
}
return this;
}
//事实上是将剩余的字符重新拷贝到字符数组value。
这里用到了system.arraycopy来拷贝数组,速度是比较快的
String 的不可变性
什么是不可变?
String不可变很简单,如下图,给一个已有字符串”abcd”第二次赋值成”abcedl”,不是在原内存地址上修改数据,而是重新指向一个新对象,新地址。
翻开JDK源码,java.lang.String类起手前三行,是这样写的:
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
/** String本质是个char数组. 而且用final关键字修饰.*/
private final char value[]; ... ...
}
首先String类是用final关键字修饰,这说明String不可继承。再看下面,String类的主力成员字段value是个char[]数组,而且是用final修饰的。
总结:
1 首先final修饰的类只保证不能被继承,并且该类的对象在堆内存中的地址不会被改变。
2 但是持有String对象的引用本身是可以改变的,比如他可以指向其他的对象。
3 final修饰的char数组保证了char数组的引用不可变。但是可以通过char[0] = ‘a’来修改值。
不过String内部并不提供方法来完成这一操作,所以String的不可变也是基于代码封装和访问控制的
微信公众号: