String(java.lang.String)
不可变性
- public final class String{xxx…}
- 以final修饰,表示String类不可被继承
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
- 内部为一个char数组,也被初始化为final,一旦被初始化后就不可变。并且 String 内部没有改变 value 数组的方法,因此可以保证 String 不可变。
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 Pool
字符串常量池(String Pool)保存着所有字符串字面量(literal strings),这些字面量在编译时期就确定。不仅如此,还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。
当一个字符串调用 intern() 方法时,如果 String Pool 中已经存在一个字符串和该字符串值相等(使用 equals() 方法进行确定),那么就会返回 String Pool 中字符串的引用;否则,就会在 String Pool 中添加一个新的字符串,并返回这个新字符串的引用。
下面示例中,s1 和 s2 采用 new String() 的方式新建了两个不同字符串,而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中,然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2); // false
String s3 = s1.intern();
String s4 = s1.intern();
System.out.println(s3 == s4); // true
如果是采用 “bbb” 这种字面量的形式创建字符串,会自动地将字符串放入 String Pool 中。
String s5 = "bbb";
String s6 = "bbb";
System.out.println(s5 == s6); // true
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);
System.out.println(s1 == s3);
}
String类型的equals
//重写Object的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;
}
String,StringBuffer,StringBuilder,以及对String不变性的理解
-
String、StringBuffer、StringBuilder
- 都是 final 类,都不允许被继承
- String 长度是不可变的,StringBuffer、StringBuilder 长度是可变的
- StringBuffer 是线程安全的,StringBuilder 不是线程安全的,但它们两个中的所有方法都是相同的,StringBuffer 在 StringBuilder 的方法之上添加了 synchronized 修饰,保证线程安全
- StringBuilder 比 StringBuffer 拥有更好的性能
- 如果一个 String 类型的字符串,在编译时就可以确定是一个字符串常量,则编译完成之后,字符串会自动拼接成一个常量。此时 String 的速度比 StringBuffer 和 StringBuilder 的性能好的多
-
String 不变性的理解
- String 类是被 final 进行修饰的,不能被继承
- 在用 + 号链接字符串的时候会创建新的字符串
- String s = new String(“Hello world”); 可能创建两个对象也可能创建一个对象。如果静态区中有 “Hello world” 字符串常量对象的话,则仅仅在堆中创建一个对象。如果静态区中没有 “Hello world” 对象,则堆上和静态区中都需要创建对象。
- 在 Java 中, 通过使用 “+” 符号来串联字符串的时候,,实际上底层会转成通过 StringBuilder 实例的 append() 方法来实现。
StringBuilder,StringBuffer底层
append
/**
* 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方法中调用到了一个函数
//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来拷贝数组,速度是比较快的