String,StringBuffer与StringBuilder类是我们比较常用的三个类,弄懂它们也是很重的,下面是我学习之后对这三个类的总结,欢迎评论纠错
String类
用法:
1、String对象用于保存字符串,也就是一组字符序列
2、字符串常量(如 "Tom"
)对象是用双引号括起的字符序列。例如:“你好”、“12.2”等
3、字符串的字符使用的是Unicode字符编码,一个字符占2个字节
4、String类较常用的构造方法有:
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startindex,int count):
String s5 = new String(byte[] b);
5、下图中展示了String类实现的3个接口,其中实现Serializable
,说明String可以串行化,实现了Comparable
,说明String对象可以比较大小
6、String是final类,不能被其他的类继承
7、在源码中,String类有属性 private final char value[]
,用来存放字符串内容,也是final类型,则这个value不能指向新的地址,但是单个字符内容可以变化。
例如:
package string;
public class String_01 {
public static void main(String[] args) {
String name="nihao";
final char[] value = {'1','2','3'};
char[] value_1={'a','b','c'};
value[0] = 'A';
System.out.println(value);
// value =value_1; (这样写就会出现 Cannot assign a value to final variable 'value')
}
}
输出结果:
A23
创建String类的方式
方式:
1、直接赋值:String str="abc";
2、调用构造器:String str= new String("abc");
解释:
方法1 :先从常量池中查看是否有“abc”数据空间,如果有,直接指向;如果没有则重新创建,然后指向。str最终指向的是常量池的空间地址
方法2 :先在堆中创建空间,里面维护了一个value属性,指向常量池的“abc”空间。如果常量池没有”abc“ ,重新创建,如果有,直接通过value指向。最终指向的是堆中的空间地址。
例如:
package string;
public class String_02 {
public static void main(String[] args) {
String str1 = "ABC"; //指向常量池中的“ABC”
String str2 = "ABC";
System.out.println(str1.equals(str2));
System.out.println(str1==str2);
}
}
输出结果:
true
true
注意:
String在调用intern 方法时,如果常量池已经包含一个等于此String 对象的字符串( 用equals()
方法确定 ),则返回常量池中的字符串,否则将此String对象添加到池中,并返回此String对象的引用。
例如:
package string;
public class String_03 {
public static void main(String[] args) {
String str1="abc"; //str1指向常量池的“abc”
String str2= new String("abc");//str2指向堆中对象
String str3= new String("abc");
System.out.println(str1.equals(str2));
System.out.println(str1 == str2);
System.out.println(str1==str2.intern());
System.out.println(str1==str2.intern());
System.out.println();
System.out.println(str2.equals(str3));
System.out.println(str2 == str3);
System.out.println(str2==str3.intern());
System.out.println(str2==str3.intern());
}
}
输出结果:
true
false
true
true
true
false
false
false
package string;
public class String_04 {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "abc";
//首先创建一个 StringBuilder sb = new StringBuilder();
//然后执行 sb.append("hello");
//之后 String str =sb.toString();
//最后 str指向堆中的对象(String) value[]指向 常量池中 “helloabc”
String str = str1 + str2;
String s1 = new String("helloabc");
String s2 = "helloabc";
String s = "hello" + "abc"; //s指向常量池
//直接看对象指向哪里?
System.out.println("是否s1==str? "+(s1==str));
System.out.println("是否s2==str? "+(s2==str));
System.out.println("是否s==s2? "+ (s==s2));
}
}
输出结果
是否s1==str? false
是否s2==str? false
是否s==s2? true
StringBuffer
用法:
1、java.lang.StringBuffer
代表可变的字符序列,可以对字符串内容进行增删。很多方法与String相同,但StringBuffer是可变长度的。
2、StringBuffer是一个容器
3、下图中 可以看出 StringBuffer 的直接父类是AbstractStringBuffer
,StringBuffer 实现了Serializable,即StringBuffer的对象可以串行化
4、在父类中 AbstractStringBuffer
类 具有属性 char[] value
,不是final类型,该value数组存放字符串内容,因此存放在堆中
5、StringBuffer 是一个final类,不能被继承
6、StringBuffer常用的几个构造器
StringBuffer s1=new StringBuffer();
( 创建一个大小为16字节的char[] ,用于存放字符内容 )
StringBuffer s2=new StringBuffer(CharSequence seq);
StringBuffer s3=new StringBuffer(int capacity);
(可以指定char[]大小)
StringBuffer s4=new(String str);
(通过给一个String创建StringBuffer,char[]大小就是str.length+16)
7、常用的StringBuffer类中的方法
例如:
package stringbuffer;
public class StringBuffer_03 {
public static void main(String[] args) {
StringBuffer str =new StringBuffer("nihao");
str.append(",");
str.append("Liangsen");
str.append("Shuanyu").append(100).append(true).append(10.5);
System.out.println(str);
System.out.println();
//删除索引为 >=start && <end 处的字符
str.delete(11,14);
System.out.println(str);
System.out.println();
//使用Tom替换索引 <=1 && >11 的字符
str.replace(1,11,"Tom");
System.out.println(str);
System.out.println();
//查找指定的子串在字符第一次出现的索引,如果找不到返回-1
int indexOf =str.indexOf("Shuanyu");
System.out.println(indexOf);
System.out.println();
//在索引为9的位置插入 Tim
str.insert(4,"Tim");
System.out.println(str);
System.out.println(str.length());
}
}
输出结果:
nihao,LiangsenShuanyu100true10.5
nihao,LiangShuanyu100true10.5
nTomShuanyu100true10.5
4
nTomTimShuanyu100true10.5
25
String VS StringBuffer
区别:
1、String保存的是字符串常量,里面的值不能更改,每次String类的更新实际上就是更改地址,效率低
2、StringBuffer保存的是字符串变量,里面的值可以更改,每次StringBuffer的更新实际上可以更新内容,不用每次更新地址,效率较高
两者转换:
1、String转为StringBuffer:方法1使用构造器,返回的是StringBuffer,对str本身没有影响。方式2使用的是append方法
2、StringBuffer转换为String:方法1使用StringBuffer提供的toString
方法,方法2使用构造器。
例如
package stringbuffer;
public class StringBuffer_02 {
public static void main(String[] args) {
//String转为StringBuffer
String str="hello Alin";
StringBuffer stringBuffer = new StringBuffer(str);
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 =stringBuffer1.append(str);
//StringBuffer转换为String
StringBuffer stringBuffer2 = new StringBuffer("nihao");
String s= stringBuffer2.toString();
String s1=new String( stringBuffer2);
}
}
StringBuilder
用法:
1、StringBuilder是一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但是不保证同步(StringBuilder不是线程安全)。该类被设计用作StringBuffer的一个简易替换,用在字符串缓冲区被单个线程使用的时候。如果可以,建议优先采用该类,因为在大多数实现中,它比StringBuffer要快
2、在·StringBuilder上的主要操作append
和insert
方法,可重载这些方法,以接受任意类型的数据。
3、StringBuilder和StringBuffer均代表可变的字符序列,方法是一样的,所以使用和StringBuffer一样
4、StringBuilder是final类型,不能被继承
5、Stringbuilder继承了AbstractStringBuilder
,其属性 char[] value
,最终的内容都是存到value(堆中)
6、实现了Serializable
接口,说明StringBuilder对象可以串行化。
7、StringBuilder的方法,没有做互斥处理,即没有synchronized
关键字,因此在单线程的情况下使用
String VS StringBuffer VS StringBuilder
1、StringBuilder和StringBuffer非常相似,均带表可变的字符序列,而且方法也是一样的
2、String:不可变字符序列,效率低,但是复用率高
3、StringBuffer:可变字符序列、效率较高(增删)、线程安全
4、StringBuilder:可变字符序列、效率最高、线程不安全
5、String使用注意说明:
String s ="a";
//创建了一个字符串
s +="b";
//实际上原来的“a”字符串对象已经丢弃了,现在又产生了一个字符串s +="b"
(也就是“ab”)。如果多次执行这些改变字符串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响程序性能,最后如果我们对String做大量的修改,不要你使用String
例如:
package stringbuilder;
public class String_VS_StringBuffer_VS_StringBuilder {
public static void main(String[] args) {
String str="";
StringBuffer strbuf = new StringBuffer("");
StringBuilder strbui = new StringBuilder("");
long startTime=0L;
long endTime=0L;
startTime=System.currentTimeMillis();
for (int i=0;i<100000;i++){
strbuf.append(String.valueOf(i));
}
endTime=System.currentTimeMillis();
System.out.println("Stringbuffer所执行的时间:"+(endTime-startTime));
startTime=System.currentTimeMillis();
for (int i=0;i<100000;i++){
strbui.append(String.valueOf(i));
}
endTime=System.currentTimeMillis();
System.out.println("StringBuilder所执行的时间:"+(endTime-startTime));
startTime=System.currentTimeMillis();
for (int i=0;i<100000;i++){
str += i;
}
endTime=System.currentTimeMillis();
System.out.println("String所执行的时间:"+(endTime-startTime));
}
}
输出结果:
Stringbuffer所执行的时间:10
StringBuilder所执行的时间:4
String所执行的时间:2042
关于String,StringBuffer,StringBuilder的选择
1、如果字符串存在大量的修改,一般可以使用StringBuffer或StringBuilder
2、如果字符串存在大量的修改并且在单线程的情况下,一般选择使用StringBuilder
3、如果字符串存在大量的修改并且在多线程的情况下,一般选择使用StringBuffer
4、如果我们的字符串很少修改,被多个对象引用,一般选择使用String