一、Java String 类——String字符串常量
字符串广泛应用 在Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串。
需要注意的是,String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,这样不仅效率低下,而且大量浪费有限的内存空间。我们来看一下这张对String操作时内存变化的图:
我们可以看到,初始String值为“hello”,然后在这个字符串后面加上新的字符串“world”,这个过程是需要重新在栈堆内存中开辟内存空间的,最终得到了“hello world”字符串也相应的需要开辟内存空间,这样短短的两个字符串,却需要开辟三次内存空间,不得不说这是对内存空间的极大浪费。为了应对经常性的字符串相关的操作,谷歌引入了两个新的类——StringBuffer类和StringBuild类来对此种变化字符串进行处理。
二、Java StringBuffer 和 StringBuilder 类——StringBuffer字符串变量、StringBuilder字符串变量
当对字符串进行修改的时候,需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是,StringBuffer 和 StringBuilder 类的对象能够被多次的修改,并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出,它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的(不能同步访问)。
由于 StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下,则必须使用 StringBuffer 类。
三者的继承结构
三者的区别:
(1)字符修改上的区别(主要,见上面分析)
(2)初始化上的区别,String可以空赋值,后者不行,报错
①String
String s = null;
String s = “abc”;
②StringBuffer
StringBuffer s = null; //结果警告:Null pointer access: The variable result can only be null at this location
StringBuffer s = new StringBuffer();//StringBuffer对象是一个空的对象
StringBuffer s = new StringBuffer(“abc”);//创建带有内容的StringBuffer对象,对象的内容就是字符串”
小结:(1)如果要操作少量的数据用 String;
(2)多线程操作字符串缓冲区下操作大量数据 StringBuffer;
(3)单线程操作字符串缓冲区下操作大量数据 StringBuilder。
一:StringBuffer的底层
(1)线程安全的字符串操作类
(2)通过synchronized关键字声明同步方法,保证多线程环境下数据安全
public synchronized StringBuffer append(String str) {
super.append(str);
return this;
}
(3)底层存储数据的Char[]数组,初始化时,该数组的长度是16。如果构造函数有新传入字符转str,则16基础上加str.length.
public StringBuffer() {
super(16);
}
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
(4)添加字符串的过程
-->先检查内部char[]数组是否需要扩容
-->如需要扩容则进行扩容,然后将原来元数据copy到新数组中。
-->再将新添加的元数据加入到新char[]数组中
public AbstractStringBuilder append(String str) {
if (str == null) str = "null";
int len = str.length();
//检查char[]数组是否需要扩容,扩容,并将原来的数据copy进去新扩容的数组中
ensureCapacityInternal(count + len);
//将新添加的数据添加到StringBuilder中的char[]数组中,实现字符串的添加
str.getChars(0, len, value, count);
count += len;
return this;
}
/**
*元数组char[]的扩容过程
*/
void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
throw new OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;
}
value = Arrays.copyOf(value, newCapacity);
}
/**
*扩容实现
*/
public static char[] copyOf(char[] original, int newLength) {
char[] copy = new char[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
二:StringBuillder的底层
(1)线程非安全的字符串操作类
(2)字符串的添加没有加同步处理,涉及到数组扩容,容易产生脏数据,破坏数据正确性
(3)底层结构和StringBuffer实现基本一样,只是没有做同步处理。
--->StringBuffer和StringBuillder都继承抽象类AbstractStringBuilder,该抽象类实现了字符串操作的方法。
--->StringBuffer和StringBuillder的实现,运用了模板方法的设计模式,将核心数据操作放在父类方法里,子类实现自己的独有特色的功能,涉及核心操作,调用父类方法。
三:String的底层
String类没有提供用于修改字符串的方法。String类对象为不可变字符串,如字符串string=”HELLO”永远只包含HELLO这几个字母,而不能修改其中任何一个字符。当然可以修改字符串变量string的引用,让它引用另一个字符串。
不可变字符串有一个优点:编译器可以让字符串实现共享。实际上只有字符串常量(使用“ ”声明,存储在字符串常量池中)是共享的,subStrng,+等操作产生的结果不能共享。
比较字符串值是否相等时使用equals()方法,不能使用==,==比较的是字符串的地址是否相同。如果字符串在常量池中,可以使用==比较,因为指向的都是同一个字符串。
直接使用 ” ” 声明的String对象会直接存储在常量池中,(可以实现共享)
1.String str1=”first”;
jvm在运行时先查找常量池中是否有该字符串,如果有则直接返回该字符串的引用给first(实现了字符串 的共享) ;否则先在常量
池中创建该字符串并返回引用。
此时只会在常量池中创建String对象,不会在堆中创建。
2.String str2=new String(“second”);
该代码生成了两个String对象。因为使用了“”会现在常量池中查找是否存在second对象,没有则创建
否则不创建;在常量池创建完成后,由于使用了new,jvm会在堆中创建内容相同的String对象,并将引用
返回给str2.
3.String str3=”what”; String str4=str3+”a nice day”;
运行时,+ 相当于new,所以堆中会有“what a nice day”对象;常量池中会有”what” “a nice day”两个对象,而不会有”what a nice day”对象。
4.三者在执行速度方面的比较:StringBuilder > StringBuffer > String