【源码分析】String、StringBuffer、StringBuilder三者区别。

简介: String 底层实际上是由 char 数组构成的,而且有 final 关键字修饰,这说明 String 类型的对象是不可以改变的,也是不可以被继承的。原始字符串永远不会更改。而是复制一份,并将要连接的文本被添加到复制的字符串之后,最后返回一个新的字符串。对大量字符串进行操作时 String 类可能会导致严重的内存泄漏和时间延迟。

前段时间在面试的过程中发现,String,StringBuffer,StringBuilder的区别这个问题几乎是面试必问的题,而且在以后的开发中使用的频率极高,懂得底层原理对以后的开发效率会有大大的提高,所以在此进行总结。


三者间关系


很多同学在刚接触到这三个类的时候,总是搞不清楚他们三个间的关系,下面我们从JDK源码分析一下:


public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence,
               Constable, ConstantDesc {
    }
 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, Comparable<StringBuffer>, CharSequence{
    }
public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, Comparable<StringBuilder>, CharSequence{
    }
abstract class AbstractStringBuilder implements Appendable, CharSequence {}


StringBuffer和StringBuilder都继承自AbstractStringBuilder这个类,而AbstractStringBuilder和String都继承自Object这个类(Object是所有java类的超类)。所以这三个类之间的关系可以大致表示为:

1.png



String


2.png

从上图可以看出:String 底层实际上是由 char 数组构成的,而且有 final 关键字修饰,这说明 String 类型的对象是不可以改变的,也是不可以被继承的。原始字符串永远不会更改。而是复制一份,并将要连接的文本被添加到复制的字符串之后,最后返回一个新的字符串。对大量字符串进行操作时 String 类可能会导致严重的内存泄漏和时间延迟。

3.png



那么,平时我们使用“+”来拼接字符串是什么实现的?

如上面的代码,首先创建一个 String 对象 a,再把“abc”赋值给它,后面Java虚拟机又创建了一个 String 对象 a,然后再把原来的 a 的值和 hello 加起来再赋值给新的 a,而原来的a 就会被Java虚拟机的垃圾回收机制(GC)给回收掉了,所以,a 实际上并没有被更改,也就是前面说的String 对象一旦创建之后就不可更改了。从这里可以看出对于频繁操作的字符串,不建议使用 String 类型,这将会是一个不断创建新的对象并且将旧的对象回收的一个过程,所以执行速度很慢。


StringBuffer


4.png

从源码中我们可以看出,对 StringBuffer 来说,底层也是 char 数组。StringBuffer 默认初始空间是16。对于 StringBuffer 的扩容,从下面可以看出,是在旧的数组的2倍上面,再加2进行扩容。


 

  public void ensureCapacity(int minimumCapacity) {
        if (minimumCapacity > 0) {
            ensureCapacityInternal(minimumCapacity);
        }
    }
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        int oldCapacity = value.length >> coder;
        if (minimumCapacity - oldCapacity > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity) << coder);
        }
    }
    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = value.length >> coder;
        int newCapacity = (oldCapacity << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        return (newCapacity <= 0 || SAFE_BOUND - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }
    private int hugeCapacity(int minCapacity) {
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        int UNSAFE_BOUND = Integer.MAX_VALUE >> coder;
        if (UNSAFE_BOUND - minCapacity < 0) { // overflow
            throw new OutOfMemoryError();
        }
        return (minCapacity > SAFE_BOUND)
            ? minCapacity : SAFE_BOUND;
    }

下面我们在来看下 StringBuffer 的操作函数append,append 方法是由 synchronized 修饰的,是线程安全的。适合于多线程环境中


  @Override
    public synchronized StringBuffer append(Object obj) {
        toStringCache = null;
        super.append(String.valueOf(obj));
        return this;
    }
    @Override
    @HotSpotIntrinsicCandidate
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }


StringBuilder


public StringBuilder() {
    super(16);
}
public StringBuilder(int capacity) {
    super(capacity);
}
public StringBuilder(String str) {
    super(str.length() + 16);
    append(str);
}
public StringBuilder(CharSequence seq) {
    this(seq.length() + 16);
    append(seq);
}

通过和 StringBuffer 的源码比较,我们发现初始空间也是16。当然也可以指定初始容量,或者以一个已有的字符序列给StringBuilder对象赋初始值。StringBuilder 和 StringBuffer 都是从 AbstractStringBuilder 继承来的,所以对于其初始空间和扩容都是相同的。

    @Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }
    @Override
    @HotSpotIntrinsicCandidate
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

对于 StringBuilder 和 StringBuffer 的区别可以从上看出,对于append()方法,缺少了synchronized 修饰,这使得 StringBuilder 不是线程安全。StringBuilder适合于单线程环境中


性能比较


public class Text1 {
    public static void main(String[] args) {
        int num = 100000;
        String a = "abc";
        long time = System.currentTimeMillis();
        for (int i = 1; i < num; i++) {
            a = a + i;
        }
        System.out.println(System.currentTimeMillis() - time);
        long time1 = System.currentTimeMillis();
        StringBuffer bf = new StringBuffer();
        for (int i = 1; i < num; i++) {
            bf.append(i);
        }
        System.out.println(System.currentTimeMillis() - time1);
        StringBuilder builder = new StringBuilder();
        long time2 = System.currentTimeMillis();
        for (int i = 1; i < num; i++) {
            builder.append(i);
        }
        System.out.println(System.currentTimeMillis() - time2);
    }
}

运行结果如下:


4134
4
3
Process finished with exit code 0

这三者的效率是:StringBuilder > StringBuffer > String。



总结


String 类被 final 关键字所修饰 String 是不可变类型

原始字符串永远不会更改。而是复制一份,并将要连接的文本被添加到复制的字符串之后,最后返回一个新的字符串

对大量字符串进行操作时 String 类可能会导致严重的内存泄漏和时间延迟。

StringBuilder和StringBuffer都是可变字符串,前者线程不安全,后者线程安全。

StringBuilder和StringBuffer的大部分方法均调用父类AbstractStringBuilder的实现。其扩容机制首先是把容量变为原来容量的2倍加2。最大容量是Integer.MAX_VALUE,也就是0x7fffffff。

StringBuilder和StringBuffer的默认容量都是16,最好预先估计好字符串的大小避免扩容带来的时间消耗。

-性能方面 StringBuilder > StringBuffer > String。


相关文章
|
28天前
|
存储 安全 Java
【JAVA基础】String、StringBuilder和StringBuffer的区别——巨详细
String是不可变的,StringBuilder和StringBuffer是可变的。而StringBuffer是线程安全的,而StringBuilder是非线程安全的。
|
19天前
|
存储 XML 缓存
Java字符串内幕:String、StringBuffer和StringBuilder的奥秘
Java字符串内幕:String、StringBuffer和StringBuilder的奥秘
19 0
|
1月前
|
存储 安全 前端开发
Java中的String类与StringBuilder、StringBuffer的比较:缺点与解决办法
Java中的String类与StringBuilder、StringBuffer的比较:缺点与解决办法
41 0
|
1月前
|
安全
String和StringBuffer、StringBuilder的区别
String和StringBuffer、StringBuilder的区别
|
29天前
|
Java
String类中的一些常用方法(JAVA)
字符串比较方法: boolean equals(Object anObject):  int compareTo(String s): int compareToIgnoreCase(String str) 字符串查找方法: char charAt(int index): int indexOf(int ch):  int indexOf(int ch, int fromIndex): int indexOf(String str): int indexOf(String str, int fromIndex): int lastIndexOf(int ch): int
46 0
|
2月前
|
安全 Java 调度
Java基础面试,String,StringBuffer,StringBuilder区别以及使用场景
* String是final修饰的,不可变,每次操作都会产生新的对象。 * StringBuffer和StringBuilder都是在原对象上进行操作 * StringBuffer是线程安全的,StringBuilder是线程不安全的。 * StringBuffer方法是被synchronized修饰的
|
7天前
|
Java
百度搜索:蓝易云【Java中如何向一个string类型的数组中添加数据】
在上述代码中,我们首先创建一个新的String数组 `newArray`,长度为原数组 `originalArray`的长度加1。然后,通过循环将原数组中的元素复制到新数组中。最后,将新数据 `newData`添加到新数组的末尾。现在,`newArray`就包含了原数组的所有元素,并且在末尾添加了新的数据。 买CN2云服务器,免备案服务器,高防服务器,就选蓝易云。百度搜索:蓝易云
8 0
|
19天前
|
安全 Java 索引
Java中的字符串String
Java中的字符串String
33 0
|
1月前
|
安全 Java 索引
java中两个String字符串比较去重
java中两个String字符串比较去重
12 0
|
1月前
|
存储 缓存 自然语言处理
Java中的String类:原理、设计思想和与数组比较的优势
Java中的String类:原理、设计思想和与数组比较的优势
18 0