美文网首页
Java 从源码角度理解String StringBuffer

Java 从源码角度理解String StringBuffer

作者: Master_Yang | 来源:发表于2018-03-20 18:38 被阅读0次

    Java里面提供了String,StringBuffer和StringBuilder三个类来封装字符串,其中StringBuilder类是到jdk 1.5才新增的。字符串操作可以说是几乎每门编程语言中所必不可少的,你真的理解其内幕吗?

    下面让我们开始探秘之旅吧!

    1. 既然都是用来封装字符串的,那为什么还要3个类来封装呢?

    2. 它们三者之间到底有何区别?

    3. 它们三者之间的使用场景分别是什么?

    4. 它们三者之间从内存角度来看又是怎么来实现的呢?

    5. 它们三者之间的性能效率是怎么排列的?

    下面就让我们逐一破解这几个谜团吧!

    一. 概述

    字符串是由若干个字符线性排列组成的,所以我们可以把字符串当作数组(Array)来看待。众所周知,数组就是内存里线性排列的有序地址空间块。既然是线性排列,有序的一组地址块,那么在分配数组空间时就必须指定空间大小也就是数组大小,这也是大多数编程语言里规定在定义数组时要指定数组大小的原因( 某些编程语言中可变数组的实现另当别论)。换言之, 数组就分为可变数组和不可变数组。可变数组能够动态插入和删除,而不可变数组一旦分配好空间后则不能进行动态插入或删除操作。

    二. 从实际应用可能的场景中分析String,StringBuilder,StringBuffer产生的背景

    在实际应用当中我们可能会对字符串经常做如下几种操作:插入,删除,修改,拼接,截取,查到,替换……其中,“插入”和“删除”操作就涉及到对原字符串的长度 进行修改( 其实,“拼接”和“截取”也分为可以理解为插入和删除操作 )。

    然而,在jdk 1.0中就出现的 String类封装的字符串是不可变的 ,即不能在原字符串上进行 插入 和 删除 操作,String的API是通过新建临时变量的方式来实现字符串的插入和删除操作。因为是新建临时变量,所以 当你调用String类的API对字符串进行插入和删除操作时原来的字符串是不会有任何改变的,返回给你的是一个新的字符串对象 。关于这一点,我们将在后面通过分析源码的方式来证实!既然String类封装的是不可变数组,那么对应的就应该有一个类来封装可变数组。没错! StringBuffer类封装的就是可变数组,并且还是线程安全的。 所以,在非多线程环境下效率相对较低。正如大家所想的一样,JDK里也提供了非多线程环境下使用的可变字符串的封装类,它就是在jdk 1.5里面才姗姗来迟的StringBuilder类, StringBuilder类是非线程安全的可变字符串封装类 ,也是我们今天要讨论的成员之一。

    到此,我们基本上就已经回答了在文章开始处提出的第1,2,3个问题。接下来,我们再从源码的角度来更深入讨论。

    三. 从源码角度进一步探讨其内部实现方式

    1. String类的关键源码分析如下
    public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence {
        /** The value is used for character storage. */
       private final char value[];//final类型char数组
    //省略其他代码……
    ……
    }
    

    从上述的代码片段中我们可以看到,String类在类开始处就定义了一个final 类型的char数组value。也就是说通过 String类定义的字符串中的所有字符都是存储在这个final 类型的char数组中的。

    下面我们来看一下String类对字符串的截取操作,关键源码如下:

    public String substring(int beginIndex) {
            if (beginIndex < 0) {
                throw new StringIndexOutOfBoundsException(beginIndex);
            }
            int subLen = value.length - beginIndex;
            if (subLen < 0) {
                throw new StringIndexOutOfBoundsException(subLen);
            }
           //当对原来的字符串进行截取的时候(beginIndex >0),返回的结果是新建的对象
            return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
        }
    

    当我们对字符串从第beginIndex(beginIndex >0) 个字符开始进行截取时,返回的结果是重新new出来的对象。所以,在对String类型的字符串进行大量“插入”和“删除”操作时会产生大量的临时变量。

    1. StringBuffer和StringBuilder类关键源码分析:

    在进行这两个类的源码分析前,我们先来分析下一个抽象类AbstractStringBuilder,因为,StringBuffer和StringBuilder都继承自这个抽象类,即AbstractStringBuilder类是StringBuffer和StringBuilder的共同父类。AbstractStringBuilder类的关键代码片段如下:

    abstract class AbstractStringBuilder implements Appendable, CharSequence {
        /**
         * The value is used for character storage.
         */
        char[] value;//一个char类型的数组,非final类型,这一点与String类不同
    
        /**
         * This no-arg constructor is necessary for serialization of subclasses.
         */
        AbstractStringBuilder() {
        }
    
        /**
         * Creates an AbstractStringBuilder of the specified capacity.
         */
        AbstractStringBuilder(int capacity) {
            value = new char[capacity];//构建了长度为capacity大小的数组
        }
    
    //其他代码省略……
    ……
    }
    

    StringBuffer类的关键代码如下:

    public final class StringBuffer
        extends AbstractStringBuilder
        implements java.io.Serializable, CharSequence
    {
       /**
         * Constructs a string buffer with no characters in it and an
         * initial capacity of 16 characters.
         */
        public StringBuffer() {
            super(16);//创建一个默认大小为16的char型数组
        }
    
        /**
         * Constructs a string buffer with no characters in it and
         * the specified initial capacity.
         *
         * @param      capacity  the initial capacity.
         * @exception  NegativeArraySizeException  if the {@code capacity}
         *               argument is less than {@code 0}.
         */
        public StringBuffer(int capacity) {
            super(capacity);//自定义创建大小为capacity的char型数组
        }
    //省略其他代码……
    ……
    

    StringBuilder类的构造函数与StringBuffer类的构造函数实现方式相同,不贴代码了。

    下面来看看StringBuilder类的append方法和insert方法的代码,因StringBuilder和StringBuffer的方法实现基本上一致,不同的是StringBuffer类的方法前多了个synchronized关键字,即StringBuffer是线程安全的。所以接下来我们就只分析StringBuilder类的代码了。StringBuilder类的append方法,insert方法都是Override 父类AbstractStringBuilder的方法,所以我们直接来分析AbstractStringBuilder类的相关方法。

    public AbstractStringBuilder append(String str) {
            if (str == null)
                return appendNull();
            int len = str.length();
           //调用下面的ensureCapacityInternal方法
            ensureCapacityInternal(count + len);
            str.getChars(0, len, value, count);
            count += len;
            return this;
        }
    
    private void ensureCapacityInternal(int minimumCapacity) {
            // overflow-conscious code
            if (minimumCapacity - value.length > 0)
               //调用下面的expandCapacity方法实现“扩容”特性
                expandCapacity(minimumCapacity);
        }
    
       /**
         * This implements the expansion semantics of ensureCapacity with no
         * size check or synchronization.
         */
        void expandCapacity(int minimumCapacity) {
           //“扩展”的数组长度是按“扩展”前数组长度的2倍再加上2 byte的规则来扩展
            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返回的新的char[]对象,从而达到“扩容”的特性
            value = Arrays.copyOf(value, newCapacity);
        }
    

    从上述代码分析得出,StringBuilder和StringBuffer的append方法“扩容”特性本质上是通过调用Arrays类的copyOf方法来实现的。接下来我们顺藤摸瓜,再分析下Arrays.copyOf(value, newCapacity)这个方法吧。代码如下:

    public static char[] copyOf(char[] original, int newLength) {
            //创建长度为newLength的char数组,也就是“扩容”后的char 数组,并作为返回值
            char[] copy = new char[newLength];
            System.arraycopy(original, 0, copy, 0,
                             Math.min(original.length, newLength));
            return copy;//返回“扩容”后的数组变量
        }
    

    其中,insert方法也是调用了expandCapacity方法来实现“扩容”特性的,此处就不在赘述了。

    接下来,分析下delete(int start, int end)方法,代码如下:

    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) {
                //调用native方法arraycopy对value数组进行复制操作,然后重新赋值count变量达到“删除”特性
                System.arraycopy(value, start+len, value, start, count-end);
                count -= len;
            }
            return this;
        }
    

    从源码可以看出delete方法的“删除”特性是调用native方法arraycopy对value数组进行复制操作,然后重新赋值count变量实现的

    最后,来看下substring方法,源码如下 :

    public String substring(int start, int end) {
            if (start < 0)
                throw new StringIndexOutOfBoundsException(start);
            if (end > count)
                throw new StringIndexOutOfBoundsException(end);
            if (start > end)
                throw new StringIndexOutOfBoundsException(end - start);
            //根据start,end参数创建String对象并返回
            return new String(value, start, end - start);
        }
    

    四. 总结

    1. String类型的字符串对象是不可变的,一旦String对象创建后,包含在这个对象中的字符系列是不可以改变的,直到这个对象被销毁。

    2. StringBuilder和StringBuffer类型的字符串是可变的,不同的是StringBuffer类型的是线程安全的,而StringBuilder不是线程安全的

    3. 如果是多线程环境下涉及到共享变量的插入和删除操作,StringBuffer则是首选。如果是非多线程操作并且有大量的字符串拼接,插入,删除操作则StringBuilder是首选。毕竟String类是通过创建临时变量来实现字符串拼接的,耗内存还效率不高,怎么说StringBuilder是通过JNI方式实现终极操作的。

    4. StringBuilder和StringBuffer的“可变”特性总结如下:

      • append,insert,delete方法最根本上都是调用System.arraycopy()这个方法来达到目的

      • substring(int, int)方法是通过重新new String(value, start, end - start)的方式来达到目的。因此,在执行substring操作时,StringBuilder和String基本上没什么区别。

    此文转载自:http://blog.csdn.net/hj7jay/article/details/52770174

    相关文章

      网友评论

          本文标题:Java 从源码角度理解String StringBuffer

          本文链接:https://www.haomeiwen.com/subject/eyyjqftx.html