文章目录
前言
相信String这个类是Java中使用得最频繁的类之一,并且又是各大公司面试喜欢问到的地方,今天就来和大家一起学习一下String、StringBuilder和StringBuffer这几个类,分析它们的异同点以及了解各个类适用的场景
一、String 类
- String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且大量浪费有限的内存空间。
- 部分源码:
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;
......
-
从上面可以看出几点:
-
String类是final类,也即意味着String类不能被继承,并且它的成员方法都默认为final方法。在Java中,被final修饰的类是不允许被继承的,并且该类中的成员方法都默认为final方法。在确定不想让该方法被覆盖时,才将方法设置为final。
-
部分方法源码
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
return new String(buf, true);
}
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value; /* avoid getfield opcode */
while (++i < len) {
if (val[i] == oldChar) {
break;
}
}
if (i < len) {
char buf[] = new char[len];
for (int j = 0; j < i; j++) {
buf[j] = val[j];
}
while (i < len) {
char c = val[i];
buf[i] = (c == oldChar) ? newChar : c;
i++;
}
return new String(buf, true);
}
}
return this;
}
- 从上面的三个方法可以看出,无论是substring操作、concat还是replace操作都不是在原有的字符串上进行的,而是重新生成了一个新的字符串对象。也就是说进行这些操作后,最原始的字符串并没有被改变。
- 再次强调对String对象的任何改变都不影响到原对象,相关的任何change操作都会生成新的对象。
二、 StringBuffer
- StringBuffer是可变类,和线程安全的字符串操作类,任何对它指向的字符串的操作都不会产生新的对象。
- 每个StringBuffer对象都有一定的缓冲区容量,当字符串大小没有超过容量时,不会分配新的容量,当字符串大小超过容量时,会自动增加容量。
StringBuffer buf=new StringBuffer(); //分配长16字节的字符缓冲区
StringBuffer buf=new StringBuffer(512); //分配长512字节的字符缓冲区
StringBuffer buf=new StringBuffer("this is a test")//在缓冲区中存放了字符串,并在后面预留了16字节的空缓冲区
- 部分源码:
public StringBuffer() {
super(16);
}
public StringBuffer(int capacity) {
super(capacity);
}
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
- 部分方法源码
public synchronized String substring(int start) {
return substring(start, count);
}
public synchronized StringBuffer replace(int start, int end, String str) {
toStringCache = null;
super.replace(start, end, str);
return this;
}
public synchronized String substring(int start, int end) {
return super.substring(start, end);
}
- 从上面的方法可以看出,无论是substring 操作还是replace操作都是在原有的字符串上进行的,且都有synchronized 是线程安全的,但也因没有synchronized 导致性能比StringBuffer高。
三、StringBuilder
- StringBuilder是可变类,线程不安全的字符串操作类,任何对它指向的字符串的操作都不会产生新的对象。
- 每个StringBuffer对象都有一定的缓冲区容量,当字符串大小没有超过容量时,不会分配新的容量,当字符串大小超过容量时,会自动增加容量。
StringBuilder buf=new StringBuilder(); //分配长16字节的字符缓冲区
StringBuilder buf=new StringBuilder(512); //分配长512字节的字符缓冲区
StringBuilder buf=new StringBuilder("this is a test")//在缓冲区中存放了字符串,并在后面预留了16字节的空缓冲区
- 部分源码:
public StringBuilder() {
super(16);
}
public StringBuilder(int capacity) {
super(capacity);
}
public StringBuilder(String str) {
super(str.length() + 16);
append(str);
}
- 部分方法源码
public StringBuilder replace(int start, int end, String str) {
super.replace(start, end, str);
return this;
}
- 从上面的方法可以看出,replace操作都是在原有的字符串上进行的,且没有synchronized 是线程不安全的,但也因没有synchronized 导致性能比。
四、常用方法
String 常用方法
//length()字符串的长度
String a = "Hello Word!";
System.out.println(a.length);
//输出的结果是字符串长度10。
// charAt()截取一个字符
String a = "Hello Word";
System.out.println(a.charAt(1));
//输出的结果是字符串a的下标为1的字符e。
// getchars()截取多个字符并由其他字符串接收
String a = "Hello Word";
char[] b = new char[10];
a.getChars(0, 5, b, 0);
System.out.println(b);
//输出的结果为Hello,其中第一个参数0是要截取的字符串的初始下标(int sourceStart),
//第二个参数5是要截取的字符串的结束后的下一个下标(int sourceEnd)也就是实际截取到的下标是int sourceEnd-1,
//第三个参数是接收的字符串(char target[]),最后一个参数是接收的字符串开始接收的位置。
//getBytes()将字符串变成一个byte数组
String a = "Hello Word";
byte b[] = a.getBytes();
System.out.println(new String(b));
//输出的结果为Hello Word的byte数组。
// toCharArray()将字符串变成一个字符数组
String a = "Hello Word";
char[]b = a.toCharArray();
System.out.println(b);
//输出的结果为Hello Word字符数组。
// equals()和equalsIgnoreCase()比较两个字符串是否相等,前者区分大小写,后者不区分
String a = "Hello Word";
String b = "hello word";
System.out.println(a.equals(b));
System.out.println(a.equalsIgnoreCase(b));
//输出的结果为第一条为false,第二条为true。
// startsWith()和endsWith()判断字符串是不是以特定的字符开头或结束
String a = "Hello Word";
System.out.println(a.startsWith("ee"));
System.out.println(a.endsWith("rd"));
//输出的结果第一条为false,第二条为true。
// toUpperCase()和toLowerCase()将字符串转换为大写或小写
String a = "Hello Word";
System.out.println(a.toUpperCase());
System.out.println(a.toLowerCase());
//输出的结果第一条为“HELLO WORD”,第二条为“hello word”。
// concat() 连接两个字符串
String a = "Hello Word";
String b = "你好";
System.out.println(b.concat(a));
//输出的结果为“你好Hello Word”。
// trim()去掉起始和结束的空格
String a = " Hello Word ";
System.out.println(a.trim());
//输出的结果为“Hello Word”。
//substring()截取字符串
String a = "Hello Word";
System.out.println(a.substring(0, 5));
System.out.println(a.substring(6));
//输出的结果第一条为“Hello”,第一个参数0(beginIndex)是开始截取的位置,
//第二个参数5(endIndex)是截取结束的位置,输出的结果第二条是“Word”,参数6(beginIndex)是开始截取的位置。
//indexOf()和lastIndexOf()前者是查找字符或字符串第一次出现的地方,后者是查找字符或字符串最后一次出现的地方
String a = "Hello Word";
System.out.println(a.indexOf("o"));
System.out.println(a.lastIndexOf("o"));
//输出的结果第一条是4,是o第一次出现的下标,第二条是7,是o最后一次出现的下标。
//compareTo()和compareToIgnoreCase()按字典顺序比较两个字符串的大小,前者区分大小写,后者不区分
String a = "Hello Word";
String b = "hello word";
System.out.println(a.compareTo(b));
System.out.println(a.compareToIgnoreCase(b));
//输出的结果第一条为-32,第二条为0,两个字符串在字典顺序中大小相同,返回0。
// replace() 替换
String a = "Hello Word";
String b = "你好";
System.out.println(a.replace(a, b));
System.out.println(a.replace(a, "HELLO WORD"));
System.out.println(b.replace("你", "大家"));
//输出的结果第一条为“你好”,第二条为“HELLO WORD”,第三条为“大家好”。
StringBuffer 常用方法
StringBuffer tmp = new StringBuffer("cba");
//append(String s):将指定的字符串追加到此字符序列。
System.out.println("append():\t" + tmp.append("|append(a)"));
//Reverse():将此字符序列用其反转形式取代。
System.out.println("reverse():\t" + tmp.reverse());
//delete(int start, int end):移除此序列的子字符串中的字符。
System.out.println("delete():\t" + tmp.delete(0, 3));
//insert(int offset, int i):将 int 参数的字符串表示形式插入此序列中。
System.out.println("insert():\t" + tmp.insert(0, "|insert|"));
//replace(int start, int end, String str):使用给定 String 中的字符替换此序列的子字符串中的字符。
System.out.println("replace():\t" + tmp.replace(0, 2, "(a)"));
StringBuilder 常用方法
- 与StringBuffer类似
总结
- 一般情况下,速度从快到慢:StringBuilder>StringBuffer>String,这种比较是相对的,不是绝对的。
- 如果要操作少量的数据用 String
- 单线程操作字符串缓冲区 下操作大量数据 StringBuilder
- 多线程操作字符串缓冲区 下操作大量数据 StringBuffer