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

在看StringBuilder之前,还是来先看下AbstractStringBuilder吧成员变量//这也是较String很大的一个不同点,是可变的 char[] value;//表示目前已经用了多...

AbstractStringBuilder 源码分析

类定义abstract class AbstractStringBuilder implements Appendable, CharSequence 实现了Appendable接口,可序列化 实现了...

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

JDK源码学习--AbstractStringBuilder reverse()

public AbstractStringBuilder reverse() { //是否含代理字符 //高代理highSurrogate和低代理lowSurrogate概念请另查询char与Un...

JDK源码学习系列02----AbstractStringBuilder

因为看StringBuffer 和 StringBuilder 的源码时发现两者都继承了AbstractStringBuilder,并且很多方法都是直接super的父类AbstractStringBu...

String系列源码解析02 - AbstractStringBuilder详细介绍

String系列源码解析02 - AbstractStringBuilder详细介绍

开源JAVA爬虫crawler4j源码分析

crawler4j架构很简洁,总共就35个类,架构也很清晰: edu.uci.ics.crawler4j.crawler 基本逻辑和配置 edu.uci.ics.crawler4j...

Java多线程 -- JUC包源码分析4 -- 各种锁与无锁

说到锁,想必很多人就会被如下的各种专业名词绕晕了。本文试图厘清关于锁的各种概念,从而对锁有一个全面而深入的理解。 –自旋锁/阻塞锁  –独占锁(排它锁)/共享锁(读写锁)  –公平锁/非公平锁  –...

开源JAVA爬虫crawler4j源码分析 - 3 线程管理

一个网页爬虫,到底是怎样安全有效的管理线程的呢?

开源JAVA爬虫crawler4j源码分析 - 1 开个头

最近有需要用到爬虫程序,翻看了一下互联网上关于爬虫的一些介绍及一些开源的网络爬虫: http://www.open-open.com/68.htm 发现用nutch的人比较多,随即拿来使用。之后觉得...

06 java.lang.AbstractStringBuilder

AbstractStringBuilder 2015.01.15 ...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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