Java源码___AbstractStringBuilder类（四）

java.lang.AbstractStringBuilder分析摘要：
<1>appendCodePoint（int codePoint）方法
<2>deleteCharAt（int index）
<3>replace(int start, int end , String str)
<4>substring重载方法
<5>insert重载方法

1.appendCodePoint（int codePoint）方法
该方法会在给容器增加codePoint对应大小的容量，并且会在字符缓存区尾部新增一个codePoint对应的字符。

public AbstractStringBuilder appendCodePoint(int codePoint){
    final int count = this.count;
    if(Character.isBmpCodePoint(codePoint)){
        ensureCapacityInternal(count+1);
        value[count] = (char)codePoint;
        this.count = count +1;
    }else if(Character.isValidCodePoint(codePoint)){
        ensureCapacityInternal(count+2);
        Character.toSurrogates(codePoint, value, count);
        this.count = count+2;
    }else{
        throw new IllegalArgumentException();
    }
    return this;
}

这个方法是的属性有：public公有。
参数：codePoint
参数说明：int类型，用于新增codePoint在Unicede字符集下对应的字符。
异常：IllegalArgumentException（）
异常说明：无效参数异常，如果codePoint没有对应的字符。
返回值：AbstractStringBuilder
返回值说明：操作完毕后，返回自身对象。

该方法的主要作用是：给该字符缓存区尾部增加codePoint对应的字符（基于Unicode编码集）。然后扩大字符缓存的容量，扩充的大小为codePoint对应的存储大小。

2. deleteCharAt（int index）方法
该方法的作用是删除特殊位置的字符。

 public AbstractStringBuilder deleteCharAt(int index){
     if((index<0) || (index>=count)){
         throw new StringIndexOutOfBoundsException(index);
     }
     System.arraycopy(value,index+1,value,index,count-index-1);
     count--;
     return this;
 }

这个方法是的属性有：public公有。
参数：index
参数说明：要删除的字符位置，即下标
异常：StringIndexOutOfBoundsException（index）
异常说明：如果输入的下标不存在，则会抛出异常。
返回值：AbstractStringBuilder
返回值说明：操作完毕后，返回自身对象。

该方法的总结：删除index位置的字符。
该源码的思路是：
<1>判断角标是否存在，如果不存在则抛出StringIndexOutOfBoundsException异常。
<2>用value复制value的特殊字符序列（会少复制一个index位置的字符）从而达到删除的操作。
<3>将字符计数变量count自减1，返回this对象。

3.replace（int start， int end， String str）
该方法是用实参字符串str替换掉this字符缓存区的字符。

public AbstractStringBuilder replace(int start, int end, String str){
    if(start<0){
        throw new StringIndexOutOfBoundsException(start);
    }
    if(end<count){
        throw new StringIndexOutOfBoundsException("end > length()");
    }
    if(start > end){
        throw new StringIndexOfBoundsException("start > end")
    }
    if(end > count){
        end = count;
    }
    int len = str.length;
    int newCount = count + len -(end-start);
    ensureCapacityInternal(newCount);
    System.arraycopy(value, end, value, start+len, count-end);
    str.getChars(value, start);
    count = newCount;
    return this;
}

这个方法是的属性有：public公有。
参数：start
参数说明：int类型，即下标位置
参数：end
参数说明：int类型，即下标位置
参数：str
参数说明：字符串，要替换成的字符串
异常：StringIndexOutOfBoundsException
异常说明：当传入的角标越界（除了end超过上限），则会抛出该异常。
返回值：AbstractStringBuilder类
返回值说明：操作完毕后，返回本身。

源码思路：
<1>做校验判断，如果start小于0或大于上限以及start大于end，则会抛出异常。
<2>如果end大于上限，则给end赋值到count值。
<3>计算出替换后的字符串长度，然后用ensureCapacityInternal来扩容。
<4>扩容后，会用空格字符填充多出来的位置。
<5>进行替换操作。

4. substring重载方法

该方法是获取字符缓存的子串，然后将其返回。

public String substring(int start){
    return substring(start, count);
}

public CharSequence 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);
    }
    return new String(value, start, end-start);
}

这个方法是的属性有：public公有。
参数：start
参数说明：开始位置，下标
参数：end
参数说明：结束位置，下标
异常：StringIndexOutOfBoundsException
异常说明：如果属于的下标超出范围，则会抛出此异常。
返回值：String类
返回值说明：返回所取的子串。

该方法的主要作用是：该方法是获取字符缓存的子串，然后将其返回。

5. insert重载方法

该方法是用来比较字符串和实参sb是否具有相同的字符顺序。

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);
    }
    ensureCapacityInternal(count+len);
    System.arraycopy(value, index, value, index+len, count-index);
    System.arraycopy(str, offset, value, index, len);
    count += len;
    return this;
}

public AbstractStringBuilder insert(int offset, Object obj){
    return insert(offset, String.valueOf(obj));
}

public AbstractStringBuilder insert(int offset, String str){
    if((offset<0) || (offset>length())){
        throw new StringIndexOutOfBoundsException(offset);
    }
    if(str == null){
        str = "null";
    }
    int len = str.length();
    ensureCapacityInternal(count+len);
    System.arraycope(value,offset, value, offset+len, count-offset);
    str.getChars(value, offset);
    count += len;
    return this;
}

public AbstractStringBuilder insert(int offset, char[] str){
    if((offset<0) || (offset>length())){
        throw new StringIndexOutOfBoundsException(offset);
    }
    int len = str.length;
    ensureCapacityInternal(count+len);
    System.arraycopy(value, offset, value, offset+len, count-offset);
    System.arraycopy(str, 0, value, offset, len);
    count += len;
    return this;
}

public AbstractStringBuilder insert(int destOffset, CharSequence s){
    if(s == null){
        s = "null";
    }
    if(s instanceof String){
        return this.insert(destOffset, (String)s)
    }
    return this.insert(destOffset, s, 0, s.length());
}

public AbstractStringBuilder insert(int destOffset, CharSequence s, 
                int start, int end){
    if(s == null){
        s = "null";
    }
    if((destOffset<0) || (destOffset>length())){
        throw new IndexOutOfBoundsException("destOffset" + destOffset);
    }
    if((start<0) || (end<0) || (start>end) || (end>s.length())){
        throw new IndexOutOfBoundsException(
                "start " + start + ", end " + end + ", s.length() "
                    + s.length());
    }
    int len = end - start;
    ensureCapacityInternal(count + len);
    System.arraycopy(value, destOffset, value, destOffset+len, count-destOffset);
    for(int i = start; i<end; i++){
        value[destOffset++] = s.charAt(i);
    }
    count += len;
    return this;
}

public AbstractStringBuilder insert(int offset, boolean b){
    return insert(offset, String.valueOf(boolean));
}

public AbstractStringBuilder insert(int offset, char c){
    ensureCapacityInternal(count+1);
    System.arraycopy(value, offset, value, offset+1, count-offset);
    value[offset] = c;
    count += 1;
    return this;
}

public AbstractStringBuilder insert(int offset, int i){
    return insert(offset, String,valueOf(i));
}

public AbstractStingBuilder insert(int offset, long l){
    return insert(offset, String.valueOf(l));
}

public AbstractStringBuilder insert(int offset, float f){
    return insert(offset, String.valueOf(f));
}

public AbstractStringBuilder insert(int offset, double d){
    return insert(offset, String.valueOf(d));
}

这个方法是的属性有：public公有。
参数：index int类型，开始插入的下标位置
参数：str char数组类型，插入的字符数组
参数：offset char数组的偏移位置，即下标位置
参数：len 偏移数量

参数：offset char数组的偏移位置，即下标位置
参数：obj Object类型，要插入的对象，会被String的valueOf处理
返回值：AbstractStringBuilder类
返回值说明：操作完成后返回修改后的this对象。

该方法的主要作用是：将插入对象根据实参来来选择位置长度，然后插入到this对象，然后将this对象返回。

Java源码___AbstractStringBuilder类（四）

猜你喜欢