自己写的精简版StringBuilder类 附源码

 * 由于字符串的相加会产生了一个新的字符串，当有多个字符串相加时，就会不断的有字符串构造出来和被析构掉，当然这是相当耗资源的。
 * 所以就有了StringBuilder类。
 * StringBuilder的实现方式是这样的，默认分配16个字节的空间，如果追加的字符个数超过当前分配的空间，
 * 系统就重新分配一块两倍的空间，16,,32,64,128,256....。再把字符串的值拷贝到新的内存中。以前的内存等着垃圾回收器回收。
 * 这样也会有大量的内存被分配和回收。
 * 但StringBuilder可没有那么笨，它可以分配指定大小的连续内存用于存储字符串，如果指定的内存大小刚好容纳所有的字符串，
 * 那就不会有多余的内存分配和回收，所以在使用StringBuilder的时候，如果能估计将要存放的字符个数的话，分配恰当的内存，
 * 将会大大的提高程序的性能，可惜的是(个人认为)很多程序员在使用StringBuilder的时候都没有预分配内存。
 * 它用一个字符数组存放字符串，每次追加字符串的时候，都是往数组的后面追加字符串，
 * 所以操作字符串中指定的字符非常方便，读取所有字符串也很快。
 * 以下是我自己写的精简版的StringBuilder类。
 * 个人认为微软实现的方式跟我的差不多，由于本人技术有限（只是比较喜欢技术），没有遇到技术非常牛逼的人，也没有看过非常牛逼的代码，
 * 开源的代码看得好累，有点不知所云，所以我暂时还很难写出较好的代码，以下代码肯定漏洞百出，
 * 以下代码我自己还是用了点时间写的，对于程序的初学者来说应该有点帮助，
 * 希望程序大牛千万不要手软，多加批评，多加指导，我定虚心认真学习 源码下载

 

using System;

 namespace CthSoft
{
    public class StringBuilder
    {

#region 属性
        char[] strBuf;//存储字符串的字符数组
 
        private int capacity=16;//字符数组的容量
         public int Capacity
        {
            get { return capacity; }
            set
            {
                SetCapacity(value);
                this.capacity = value;
            }
        }

        private int length;//字符串的长度
         public int Length
        {
            get { return length; }
            set
            {
                //字符串长度不能小于0
                if (value < 0)
                {
                    throw new ArgumentOutOfRangeException("长度不能小于 0。参数名: length");
                }

                if (value == capacity)
                {
                    return;
                }

                if (value > capacity)
                {
                    this.Capacity = value;
                }
                else
                {
                    for (int i = value; i < length; i++)
                    {
                        strBuf[i] = '\0';
                    }
                }

                this.length = value;
            }
        }

        //字符数组的最大容量，即int类型的最大值(容量是int类型)
        private int maxCapacity = int.MaxValue;
        public int MaxCapacity
        {
            set { maxCapacity = value; }
            get { return maxCapacity; }
        }
        #endregion

 #region 辅助方法
        private void SetCapacity(int value)
        {
            CheckCapacitySize(value,this.maxCapacity);
            if (strBuf != null)
            {
                char[] tmpBuf = new char[value];
                Array.Copy(strBuf, tmpBuf, strBuf.Length);
                strBuf = tmpBuf;
                tmpBuf = null;
            }
            else {
                strBuf = new char[value];
            }
        }

        private void SetCapacity()
        {
            if (this.length > this.capacity)
            {
                while (this.length > this.capacity)
                {
                    this.capacity = this.capacity << 1;
                }
                SetCapacity(this.capacity);
            }
        }

        private void CheckCapacitySize(int capacity, int maxCapacity)
        {
            CheckRange(capacity);
            CheckRange(maxCapacity);
            if (maxCapacity < capacity)
            {
                throw new ArgumentOutOfRangeException("容量超出了最大容量。参数名: capacity");
            }
        }

        private void CheckRange(int index)
        {
            if (index < 0)
            {
                throw new IndexOutOfRangeException("索引超出了数组界限。参数名: index");
            }
        }

        private void CheckRange(int index, int count)
        {
            CheckRange(index);
            CheckRange(count);
            CheckRange(index + count);
        }
        #endregion

 #region 初始化
        private void Initializtion(int length)
        {
            strBuf = new char[this.capacity];
            this.length = length;
        }
         
        private void Initializtion(ref string value)
        {
            if (value == null)
            {
                Initializtion(0);
            }
            else
            {
                while (value.Length > this.capacity)
                {
                    this.capacity = this.capacity << 1;
                }
                Initializtion(value.Length);
                Array.Copy(value.ToCharArray(), strBuf, value.Length);
            }
        }

        private void Initializtion(ref string value,int capacity)
        {
            CheckRange(capacity);
            this.capacity = capacity;
            Initializtion(ref value);
        }
        #endregion

 #region 构造函数
        public StringBuilder()
        {
            Initializtion(0);
        }

        public StringBuilder(string value)
        {
            Initializtion(ref value);
        }

        public StringBuilder(string value, int capacity)
        {
            Initializtion(ref value,capacity);
        }

        public StringBuilder(int capacity)
        {
            string value = null;
            Initializtion(ref value, capacity);
        }

        public StringBuilder(int capacity, int maxCapacity)
        {
            CheckCapacitySize(capacity,maxCapacity);
            this.capacity = capacity;
            this.maxCapacity = maxCapacity;
            Initializtion(0);
        }

        public StringBuilder(string value, int startIndex, int length, int capacity) 
        {
            if (startIndex < 0 || length < 0 || startIndex >= value.Length || startIndex + length >= value.Length)
            {
                throw new ArgumentOutOfRangeException("索引和长度必须引用该字符串内的位置");
            }
            value = value.Substring(startIndex, length);
            Initializtion(ref value, capacity);
        }
        #endregion

 #region Append
        public StringBuilder Append(char[] value)
        {
            return Append(value,0,value.Length);
        }

        public StringBuilder Append(string value)
        {
            if (value == null)
            {
                value = string.Empty;
            }
            Append(value.ToCharArray());
            return this;
        }

        public StringBuilder Append(object value)
        {
            if (value == null)
            {
                value = string.Empty;
            }
            Append(value.ToString().ToCharArray());
            return this;
        }

        public StringBuilder Append(int value)
        {
            Append(value.ToString().ToCharArray());
            return this;
        }

        public StringBuilder Append(byte value)
        {
            Append(value.ToString().ToCharArray());
            return this;
        }

        public StringBuilder Append(long value)
        {
            Append(value.ToString().ToCharArray());
            return this;
        }

        public StringBuilder Append(float value)
        {
            Append(value.ToString().ToCharArray());
            return this;
        }

        public StringBuilder Append(double value)
        {
            Append(value.ToString().ToCharArray());
            return this;
        }

        public StringBuilder Append(decimal value)
        {
            Append(value.ToString().ToCharArray());
            return this;
        }

        public StringBuilder Append(bool value)
        {
            if (value)
            {
                Append("True".ToCharArray());
            }
            else {
                Append("False".ToCharArray());
            }
            return this;
        }

        public StringBuilder Append(char value, int repeatCount)
        {
            if (repeatCount < 0)
            {
                throw new ArgumentOutOfRangeException("字符的数量必须大于零，参数repeatCount");
            }
            char[] tmpBuf = new char[repeatCount];
            for (int i = 0; i < repeatCount; i++)
            {
                tmpBuf[i] = value;
            }
            return Append(tmpBuf);
        }

        public StringBuilder Append(char[] value, int startIndex, int charCount)
        {
            if (value == null)
            {
                value = new char[] { '\0' };
            }
            if (startIndex < 0 || charCount < 0 || startIndex + charCount > value.Length)
            {
                throw new IndexOutOfRangeException("索引超出了数组界限。参数名: index");
            }
            this.length = this.length + charCount;
            SetCapacity();
            Array.Copy(value, startIndex, strBuf, this.length - value.Length, charCount);
            return this;
        }


        public StringBuilder AppendFormat(string format, object arg0) 
        {
            return Append(string.Format(format, arg0));
        }

        public StringBuilder AppendFormat(string format, params object[] args)
        {
            return Append(string.Format(format, args));
        }

        public StringBuilder AppendFormat(string format, object arg0, object arg1)
        {
            return Append(string.Format(format, arg0,arg1));
        }

        public StringBuilder AppendFormat(string format, object arg0, object arg1, object arg2)
        {
            return Append(string.Format(format, arg0, arg1,arg2));
        }
        #endregion

#region Insert
        public StringBuilder Insert(int index, char[] value)
        {
            if (value == null)
            {
                return this;
            }
            if (index < 0 || index > this.length)
            {
                throw new IndexOutOfRangeException("索引超出了数组界限。参数名: index");
            }

            this.length = this.length + value.Length;
            if (this.length > this.capacity)
            {
                SetCapacity(this.length);
            }
             
            for (int i = this.length-1-value.Length; i >=index ; i--)
            {
                strBuf[i + value.Length] = strBuf[i];
            }
            for (int i = 0; i < value.Length; i++)
            {
                strBuf[index + i] = value[i];
            }
             
            return this;
        }

        public StringBuilder Insert(int index, string value)
        {
            if (value == null)
            {
                return this;
            }
            return Insert(index,value.ToCharArray());
        }

        public StringBuilder Insert(int index, byte value)
        {
            return Insert(index, value.ToString().ToCharArray());
        }

        public StringBuilder Insert(int index, char value)
        {
            CheckRange(index);
            this.length++;
            if (this.length > this.capacity)
            {
                SetCapacity(this.length);
            }

            for (int i = this.length - 2; i >= index; i--)
            {
                strBuf[i + 1] = strBuf[i];
            }
            strBuf[index] = value;
            return this;
        }

        public StringBuilder Insert(int index, int value)
        {
            return Insert(index, value.ToString().ToCharArray());
        }

        public StringBuilder Insert(int index, long value)
        {
            return Insert(index, value.ToString().ToCharArray());
        }

        public StringBuilder Insert(int index, double value)
        {
            return Insert(index, value.ToString().ToCharArray());
        }

        public StringBuilder Insert(int index, object value)
        {
            return Insert(index, value.ToString().ToCharArray());
        }

        public StringBuilder Insert(int index, short value)
        {
            return Insert(index, value.ToString().ToCharArray());
        }

        public StringBuilder Insert(int index, decimal value)
        {
            return Insert(index, value.ToString().ToCharArray());
        }

        public StringBuilder Insert(int index, float value)
        {
            return Insert(index, value.ToString().ToCharArray());
        }

        public StringBuilder Insert(int index, string value, int count)
        {
            if (value == null)
            {
                return this;
            }
            CheckRange(index);
            if (count < 0)
            {
                throw new ArgumentOutOfRangeException("index 小于零或大于此实例的当前长度。- 或 - count 小于零");
            }
            if (value.Length * count+this.length > this.maxCapacity)
            {
                throw new OutOfMemoryException("对象的当前长度加上 value 的长度乘以 count 的值超过StringBuilder.MaxCapacity。");
            }
            char[] tmpBuf = new char[value.Length * count];
            for (int i = 0; i < count; i++)
            {
                Array.Copy(value.ToCharArray(),0,tmpBuf, value.Length*i,value.Length);
            }
            Insert(index,tmpBuf);
            tmpBuf = null;
            return this;
        }

        public StringBuilder Insert(int index, char[] value, int startIndex, int charCount)
        {
            if (value == null || value.Length == 0)
            {
                return this;
            }

            if (index<0 || charCount<0 ||startIndex + charCount>value.Length)
            {
                throw new IndexOutOfRangeException("索引超出了数组界限。参数名: charCount");
            }

            char[] tmpBuf = new char[charCount];
            Array.Copy(value,startIndex,tmpBuf,0,charCount);
            Insert(index, tmpBuf);
            tmpBuf = null;
            return this;
        }



        #endregion 

 #region remove
        public StringBuilder Remove(int startIndex, int length)
        {
            CheckRange(startIndex , length);

            for (int i = startIndex + length; i < this.length; i++)
            {
                strBuf[startIndex++] = strBuf[i];
            }
            for (int i = startIndex; i < this.length; i++)
            {
                strBuf[i] = '\0';
            }
            this.length = this.length - length;
            return this;
        }

        public StringBuilder Remove(char[] value)
        {
            if (value == null || value.Length > this.length)
            {
                return this;
            }
            int k,t;
            for (int i = 0; i < this.length; i++)
            {
                if (value[0] == strBuf[i])
                {
                    k = i;
                    t=0;
                    while (k < this.length && t < value.Length)
                    {
                        if (value[t++] != strBuf[k++])
                        {
                            break;
                        }

                        if (t == value.Length)
                        {
                           return Remove(i, t);
                        }
                    }
                }
            }
            return this;
        }

        public StringBuilder Remove(string value)
        {
            if (value == null)
            {
                return this;
            }
            return Remove(value.ToCharArray());
        }
         
        public StringBuilder RemoveAll(string value)
        {
            if (value == null || value.Length > this.length)
            {
                return this;
            }
            int k, t;
            for (int i = 0; i < this.length; i++)
            {
                if (value[0] == strBuf[i])
                {
                    k = i;
                    t = 0;
                    while (k < this.length && t < value.Length)
                    {
                        if (value[t++] != strBuf[k++])
                        {
                            break;
                        }

                        if (t == value.Length)
                        {
                            Remove(i, t);
                            break;
                        }
                    }
                }
            }
            return this;
        }
        #endregion

 #region replace
        public StringBuilder Replace(char oldChar, char newChar)
        {
            for (int i = 0; i < strBuf.Length;i++ )
            {
                if (strBuf[i] == oldChar)
                {
                    strBuf[i] = newChar;
                }
            }
            return this;
        }

        public StringBuilder Replace(char oldChar, char newChar, int startIndex, int count)
        {
            CheckRange(startIndex , length);

            for (int i = startIndex; i < startIndex + count; i++)
            {
                if (strBuf[i] == oldChar)
                {
                    strBuf[i] = newChar;
                }
            }
            return this;
        }

        public StringBuilder Replace(string oldValue, string newValue)
        {
            return Replace(oldValue,newValue,0,this.length);
        }

        public StringBuilder Replace(string oldValue, string newValue, int startIndex, int count)
        {
            CheckRange(startIndex , count);
            if (oldValue == null || oldValue.Length > this.length)
            {
                return this;
            }

            if (newValue == null)
            {
                newValue = string.Empty;
            }

            int i, k;
            bool isChange = false;
            for (int j = startIndex; j < startIndex+count; j++)
            {
                if (oldValue[0] == strBuf[j])
                {
                    k = j;
                    i = 0;
                    while (i <= oldValue.Length && k <= this.length)
                    {
                        if (oldValue[i++] != strBuf[k++])
                        {
                            break;
                        }
                        if (i == oldValue.Length)
                        {
                            i = 0;
                            k = j;
                            while (i < oldValue.Length && i < newValue.Length)
                            {
                                strBuf[k++] = newValue[i++];
                            }

                            if (newValue.Length > i)
                            {
                                Insert(i, newValue.Substring(i));
                            }
                            else if (oldValue.Length > i)
                            {
                                Remove(k, oldValue.Length - i);
                            }
                            isChange = true;
                            break;
                        }
                    }
                    if (isChange)
                    {
                        j = j + Math.Min(oldValue.Length , newValue.Length)-1;
                        isChange = false;
                    }
                }
            }
            return this;
        }

        #endregion

   public char this[int index]
        {
            set
            {
                CheckRange(index);
                strBuf[index] = value;
            }
            get
            {
                CheckRange(index);
                return strBuf[index];
            }
        }
         
        public override string ToString()
        {
            return new string(strBuf);
        }
         
        public string ToString(int startIndex, int length)
        {
            CheckRange(startIndex,length);
            char[] tmpBuf = new char[length];
            Array.Copy(strBuf,startIndex,tmpBuf,0,length);
            return new string(tmpBuf);
        }
         
    }
}