java源码分析(4)-AbstractStringBuilder

原创 2016年05月31日 17:13:18


AbstractStringBuilder

1.AbstractStringBuilder

为抽象类,主要的属性有两个,一个为value,一个为count,value用于存放值,count用于管理该类的容量

char value[];
int count;
public int length() {//length方法返回的是count的值,而不是value.length
	return count;
}
public int capacity() {//capacity方法返回的是value.length,用以返回容量
	return value.length;
}
public void ensureCapacity(int minimumCapacity) {
	if (minimumCapacity > value.length) {
	    expandCapacity(minimumCapacity);
	}
}
void expandCapacity(int minimumCapacity) {
	int newCapacity = (value.length + 1) * 2;//自动扩容机制,每次扩容(value.length+1)*2
        if (newCapacity < 0) {
            newCapacity = Integer.MAX_VALUE;//若传入的参数小于0,则直接把容量设置到Integer的最

大值
        } else if (minimumCapacity > newCapacity) {
	    newCapacity = minimumCapacity;//若扩容后的容量还是小于传入的参数,则将传入的参数设

为容量
	}
        value = Arrays.copyOf(value, newCapacity);
}
public void trimToSize() {
        if (count < value.length) {
            value = Arrays.copyOf(value, count);//当count小于value.length时,将value多余长度的

值删除,时value.length的长度等于count
        }
}

2.trimToSize()

  用于保留value的值,保留的长度为count的值,只有当count的值小于value.length时才起作用,

<strong> public void trimToSize() {
        if (count < value.length) {
            value = Arrays.copyOf(value, count);
        }
    }</strong>

3.setLength(int newLength)

public void setLength(int newLength) {
	if (newLength < 0)
	    throw new StringIndexOutOfBoundsException(newLength);
	if (newLength > value.length)
	    expandCapacity(newLength);//当传入的值大于value.length时,需要扩容

	if (count < newLength) {
	    for (; count < newLength; count++)
		value[count] = '\0';//为新扩容的元素赋值'\0',为结束符
	} else {
            count = newLength;//若count小于输入参数,则将count的值设置为输入的值
        }
}

4.getChars(int srcBegin, int srcEnd, char dst[],int dstBegin)

append依赖的一个方法,用以添加一个字符串数组

public void getChars(int srcBegin, int srcEnd, char dst[],
                                      int dstBegin)
    {
	if (srcBegin < 0)
	    throw new StringIndexOutOfBoundsException(srcBegin);
	if ((srcEnd < 0) || (srcEnd > count))
	    throw new StringIndexOutOfBoundsException(srcEnd);
        if (srcBegin > srcEnd)
            throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
	System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);//用于添加字符串,

将value的值添加到dst[]中
}

5.append()

在对象后拼接字符串或其他对象,效率较高,可以观察到,在拼接时并没有创建新的对象,也没有舍弃旧的对象,相对于String的机制,性能提升相当明显。

public AbstractStringBuilder append(String str) {
	if (str == null) str = "null";//若传入的字符串长度为0,则默认添加null
        int len = str.length();
	if (len == 0) return this;//若添加的字符串长度为0,则直接返回对象本身(不进行添加)
	int newCount = count + len;
	if (newCount > value.length)
	    expandCapacity(newCount);//检验容量,若容量不够则扩容
	str.getChars(0, len, value, count);//将str的值添加到value后
	count = newCount;//容量count更新
	return this;
}
public AbstractStringBuilder append(StringBuffer sb) {
	if (sb == null)
            return append("null");//传入的StringBuffer长度为零,默认添加null
	int len = sb.length();
	int newCount = count + len;
	if (newCount > value.length)
	    expandCapacity(newCount);//检验容量,有需要则执行扩容
	sb.getChars(0, len, value, count);
	count = newCount;//更新容量count的值
	return this;
}
public AbstractStringBuilder append(CharSequence s) {
        if (s == null)
            s = "null";
        //根据序列类型的不同,执行不同的添加方法
        if (s instanceof String)
            return this.append((String)s);
        if (s instanceof StringBuffer)
            return this.append((StringBuffer)s);
        return this.append(s, 0, s.length());
}
public AbstractStringBuilder append(int i) {
        if (i == Integer.MIN_VALUE) {
            append("-2147483648");//Integer最小值为特例,特殊处理
            return this;
        }
        int appendedLength = (i < 0) ? stringSizeOfInt(-i) + 1 
                                     : stringSizeOfInt(i);//判断Integer的位数,负数有负号,要

多加一位
        int spaceNeeded = count + appendedLength;
        if (spaceNeeded > value.length)
            expandCapacity(spaceNeeded);
	Integer.getChars(i, spaceNeeded, value);
        count = spaceNeeded;
        return this;
}
final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                     99999999, 999999999, Integer.MAX_VALUE };
static int stringSizeOfInt(int x) {
        for (int i=0; ; i++)
            if (x <= sizeTable[i])
                return i+1;
}

6.delete(int start, int end)

用以删除一部分的字符

public AbstractStringBuilder delete(int start, int end) {
        //验证参数的有效性
	if (start < 0)
	    throw new StringIndexOutOfBoundsException(start);
	if (end > count)
	    end = count;//结束下标大于count时,将count设为结束下标
	if (start > end)
	    throw new StringIndexOutOfBoundsException();
        int len = end - start;
        if (len > 0) {
            System.arraycopy(value, start+len, value, start, count-end);//执行删除
            count -= len;//重置count大小
        }
        return this;
}

7.replace(int start, int end, String str)

替换本身对象中的一部分字符

public AbstractStringBuilder replace(int start, int end, String str) {
        //验证参数有效性
        if (start < 0)
	    throw new StringIndexOutOfBoundsException(start);
	if (start > count)
	    throw new StringIndexOutOfBoundsException("start > length()");
	if (start > end)
	    throw new StringIndexOutOfBoundsException("start > end");

	if (end > count)
	    end = count;
	int len = str.length();
	int newCount = count + len - (end - start);//计算替换后字符串的长度以此判断是否需要进

行扩容
	if (newCount > value.length)
	    expandCapacity(newCount);
        //替换的步骤为,先删除要替换的部分,再拼接要添加的部分
        System.arraycopy(value, end, value, start + len, count - end);
        str.getChars(value, start);
        count = newCount;//更新count值
        return this;
}

8.insert(int index, char str[], int offse,int len)

在对象中间插入字符串数组

public AbstractStringBuilder insert(int index, char str[], int offset,
                                        int len)
    {
        //验证参数有效性
        if ((index < 0) || (index > length()))
	    throw new StringIndexOutOfBoundsException(index);
        if ((offset < 0) || (len < 0) || (offset > str.length - len))
            throw new StringIndexOutOfBoundsException(
                "offset " + offset + ", len " + len + ", str.length " 
                + str.length);
	int newCount = count + len;
	if (newCount > value.length)//验证是否要扩容
	    expandCapacity(newCount);
	System.arraycopy(value, index, value, index + len, count - index);//先在value中建立起

用于存放插入值的空位
	System.arraycopy(str, offset, value, index, len);//向空位中插入str
	count = newCount;//更新count值
	return this;
    }

9. reverse()

将对象本身的字符顺序调转后返回给原对象

public AbstractStringBuilder reverse() {//反转字符串
	boolean hasSurrogate = false;
	int n = count - 1;
        //采用从中间向两端遍历,对换对称位置上的字符
	for (int j = (n-1) >> 1; j >= 0; --j) {
	    char temp = value[j];
	    char temp2 = value[n - j];
	    if (!hasSurrogate) {//验证每个字符的编码是否在范围内
		hasSurrogate = (temp >= Character.MIN_SURROGATE && temp <= 

Character.MAX_SURROGATE)
		    || (temp2 >= Character.MIN_SURROGATE && temp2 <= Character.MAX_SURROGATE);
	    }
	    value[j] = temp2;
	    value[n - j] = temp;
	}
	if (hasSurrogate) {
	   //例如憨子由两个字符组成,直接反转后,用以表示一个汉字的两个字符顺序错了,需要重新

调整
	    for (int i = 0; i < count - 1; i++) {
		char c2 = value[i];
		if (Character.isLowSurrogate(c2)) {
		    char c1 = value[i + 1];
		    if (Character.isHighSurrogate(c1)) {
			value[i++] = c1;//调整两个字符的顺序
			value[i] = c2;
		    }
		}
	    }
	}
	return this;
}

可以看到,这里需要考虑到字符编码的问题,例如汉字由两个字符组成,将对称位置的字符互换后,两个用以表示一个汉字的字符顺序会颠倒,需要互换这两个字符的位置
   










版权声明:本文为博主原创文章,未经博主允许不得转载。

共同学习Java源代码--常用工具类--AbstractStringBuilder(一)

菜鸟们去面试时经常会被问道String、StringBuffer、StringBuilder什么区别?菜鸟们回答第一个是不可变字符串,后两个是可变字符串,第二个是线程安全的,第三个是线程不安全的。然后...
  • ccdust
  • ccdust
  • 2016年04月17日 14:30
  • 430

【源码】StringBuilder和StringBuffer源码深度剖析

//------------------------------------------------------------------------ 写篇博客不容易,请尊重作者劳动成果。转载请注明出...
  • RowandJJ
  • RowandJJ
  • 2014年08月06日 21:58
  • 1992

Spring源码解析之四 ------ AOP原理和源码分析

在介绍AOP之前,想必很多人都听说AOP是基于动态代理和反射来实现的,那么在看AOP之前,你需要确实弄懂动态代理和反射。 巧了,我这里就有。 JDK的动态代理的实现和源码分析,参见我的这两篇文章 JD...
  • weililansehudiefei
  • weililansehudiefei
  • 2017年06月28日 08:40
  • 333

Netty 4源码解析:请求处理

Netty 4源码解析:请求处理通过之前《Netty 4源码解析:服务端启动》的分析,我们知道在最前端“扛压力”的是NioEventLoop.run()方法。我们指定创建出的NioServerSock...
  • dc_726
  • dc_726
  • 2015年08月29日 08:14
  • 6372

Spring 源码分析(一) —— 迈向Spring之路

https://my.oschina.net/kaywu123/blog/610825 摘要: EveryBody in the world should learn how to program ...
  • achuo
  • achuo
  • 2017年06月21日 11:40
  • 643

【虚幻4】最新UE4源码-从获取到规范构建引擎:完全教学

至于为什么现在才记录在博客,因为换电脑了,需要重新下,那么就写个全面点的教程好了。        不管现不现在记录,这只是一个最初的总结现在搬出来而已,正好当前UE4版本对象是4.12.5 第一步:当...
  • sinat_35753154
  • sinat_35753154
  • 2016年08月04日 23:54
  • 6071

netty 4.x源码分析

服务端需要经过socket、bind、accept、read、write等步骤,客户端需要经过socket、connect、read、write等步骤,后续此系列文章会对每一个步骤如何发生进行分析。 ...
  • joeyon
  • joeyon
  • 2015年07月07日 17:55
  • 1407

linux源码分析

为了提高自己,不知不觉踏上了linux源码分析之路了!     我选择linux源码版本是linux 0.11,为什么选择它?因为它代码量少且资料多。     针对它的分析是建立于网上资料之上(快...
  • qk1992919
  • qk1992919
  • 2015年10月15日 16:59
  • 2709

JAVA源码分析(一)——String

String的源码分析 Java中String不是基本数据类型,而是一种特殊的类。String代表的是不可变的字符序列,为不可变对象,一旦被创建,就不能修改它的值,对于已经存在的String对象的修...
  • lu1005287365
  • lu1005287365
  • 2016年08月23日 09:25
  • 777

深入java NIO系列之缓冲区分析与源码解读(一)

数据从磁盘移动到进程的内存区域整个过程:进程发起read()系统调用,要求其缓冲区被填满,内核随即要求磁盘控制硬件发送命令,磁盘控制器直接将数据写入内核的内存缓冲区中,该过程通过DMA来完成,无需主C...
  • miliermili
  • miliermili
  • 2014年03月12日 22:48
  • 3319
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java源码分析(4)-AbstractStringBuilder
举报原因:
原因补充:

(最多只允许输入30个字)