模仿Java中StringBuilder类底层实现,最近修改了一些复制数组的方法。
package mylang;
public final class MyStringBuilder {
private char[] chars = new char[16];//数组初始长度设为16
private int capacity = 0;//初始容量为0
public MyStringBuilder(){}//默认无参构造方法
public MyStringBuilder(String str){
append(str);
}
//=============================私有的方法=======================================
private char[] growCapacity(int newCapacity){//扩容方法
if(newCapacity > chars.length){//判断是否需要扩容
char[] charsNew;
if(newCapacity > chars.length*2){//如果扩容2倍容量还是不足
charsNew = new char[newCapacity];//定义新数组长度为需要的长度
}else{
charsNew = new char[chars.length*2];//容量充足则扩容为2倍长度
}
return charsNew;
}else{
return null;
}
}
private void rangeCheck(int fromIndex){
if(fromIndex < 0 || fromIndex > capacity-1){
throw new StringIndexOutOfBoundsException("offset "+fromIndex+",length "+capacity);
}
}
private void rangeCheck(int fromIndex,int toIndex){
if(toIndex < fromIndex ||fromIndex < 0 || fromIndex > capacity-1 || toIndex > capacity-1){
throw new StringIndexOutOfBoundsException("start "+fromIndex+",end "+toIndex+",length "+capacity);
}
}
//==============================提供给外部的方法==================================
public int capacity(){
return capacity;//返回容量值
}
public int length(){
return chars.length;//返回实体大小
}
public void append(char c){//追加字符
char[] charsNew = growCapacity(capacity+1);
if(charsNew == null){
chars[capacity] = c;//保存新元素
}else{
System.arraycopy(chars,0,charsNew,0,chars.length);//原数组中的数据复制到新数组中
charsNew[capacity] = c;//保存新元素
chars = charsNew;//实体数组指针指向新数组
}
capacity++;//容量+1
}
public void append(char[] str){//追加字符数组
append(str, 0, str.length);
}
public void append(char[] str,int offset,int len){//部分追加字符数组
if(offset < 0 || offset > str.length -1|| len <0 || offset+len > str.length){
throw new ArrayIndexOutOfBoundsException();//数组下标越界抛出异常
}
char[] charsNew = growCapacity(capacity+len);
if (charsNew==null){
System.arraycopy(str,offset,chars,capacity,len);//写入每个字符
}else{
System.arraycopy(chars,0,charsNew,0,chars.length);//原数组中的数据复制到新数组中
System.arraycopy(str,offset,charsNew,capacity,len);//写入每个字符
chars = charsNew;
}
capacity += len;//更新容量
}
public void append(String str){//追加字符串
char[] tempChars = str.toCharArray();//字符串转化为字符数组
append(tempChars);
}
public void append(int i){
char[] tempChars = String.valueOf(i).toCharArray();
append(tempChars);
}
public void append(long lng){
char[] tempChars = String.valueOf(lng).toCharArray();
append(tempChars);
}
public void append(float f){
char[] tempChars = String.valueOf(f).toCharArray();
append(tempChars);
}
public void append(double d){
char[] tempChars = String.valueOf(d).toCharArray();
append(tempChars);
}
public void append(boolean b){
char[] tempChars = String.valueOf(b).toCharArray();
append(tempChars);
}
public void append(MyStringBuilder sb){
char[] str = sb.toString().toCharArray();
append(str);
}
public void insert(int offset,char c){
if(offset < 0 || offset > capacity){
throw new StringIndexOutOfBoundsException("offset "+offset+",capacity "+capacity);
}
char[] charsNew = growCapacity(capacity+1);
if(charsNew == null){
System.arraycopy(chars,offset,chars,offset+1,capacity-offset+1);
chars[offset] = c;
}else{
System.arraycopy(chars,0,charsNew,0,offset);//offset之前的元素复制
charsNew[offset] = c;//offset位置添加新元素
System.arraycopy(chars,offset,charsNew,offset+1,chars.length-offset-1);//原数组offset之后的复制到新数组
chars = charsNew;//修改指针
}
capacity ++;//容量+1
}
public void insert(int index,char[] str,int offset,int len){
if(index < 0 ||index > capacity ){
throw new StringIndexOutOfBoundsException("offset "+index+",length "+capacity);
}
if(offset < 0 || offset > str.length -1|| len < 0 ||offset+len > str.length){
throw new ArrayIndexOutOfBoundsException("start "+offset+",end "+len+",length "+str.length);//数组下标越界抛出异常
}
char[] charsNew = growCapacity(capacity+len);
if(charsNew == null){
System.arraycopy(chars,index,chars,index+len,capacity-index+1);//确定位置,后移
System.arraycopy(str,offset,chars,index,len);//依次添加新元素
}else{
System.arraycopy(chars,0,charsNew,0,index);//index之前的元素复制
System.arraycopy(str,offset,charsNew,index,len);//offset位置依次添加新元素
System.arraycopy(chars,index,charsNew,index+len,capacity-index);//原数组offset之后的复制到新数组
chars = charsNew;
}
capacity += len;//更新容量
}
public void insert(int offset,char[] str){
insert(offset,str,0,str.length);
}
public void insert(int offset,String str){
char[] tempChars = str.toCharArray();
insert(offset, tempChars);
}
public void insert(int offset,int i){
char[] tempChars = String.valueOf(i).toCharArray();
insert(offset, tempChars);
}
public void insert(int offset,long lng){
char[] tempChars = String.valueOf(lng).toCharArray();
insert(offset, tempChars);
}
public void insert(int offset,float f){
char[] tempChars = String.valueOf(f).toCharArray();
insert(offset, tempChars);
}
public void insert(int offset,double d){
char[] tempChars = String.valueOf(d).toCharArray();
insert(offset, tempChars);
}
public void insert(int offset,boolean b){
char[] tempChars = String.valueOf(b).toCharArray();
insert(offset, tempChars);
}
public void insert(int offset, MyStringBuilder sb){
char[] tempChars = String.valueOf(sb).toCharArray();
insert(offset, tempChars);
}
public int indexOf(String str,int fromIndex){
rangeCheck(fromIndex);
if(str.length() > capacity-fromIndex-1) {//字符串的长度大于要比较的字符串长度
return -1;
}
char[] tempChars = str.toCharArray();//转化为字符数组
for (int i = fromIndex; i < capacity; i++) {
if(tempChars[0] == chars[i]){
boolean isExist = true;
for (int j = 1; j < tempChars.length; j++) {
if(tempChars[j] != chars[i+j]){
isExist = false;
break;
}
}
if(isExist){
return i;
}
}
}
return -1;
}
public int indexOf(String str){
return indexOf(str, 0);
}
public int lastIndexOf(String str,int fromIndex){
rangeCheck(fromIndex);
if(str.length() > capacity-fromIndex-1) {//字符串的长度大于要比较的字符串长度
return -1;
}
char[] tempChars = str.toCharArray();
for(int i = capacity-1 ; i >= fromIndex ; i -- ){
if(tempChars[tempChars.length-1] == chars[i]){
boolean isExist = true;
for (int j = tempChars.length-2; j >= 0 ; j--) {
if(tempChars[j] != chars[i-tempChars.length+j+1]){
isExist = false;
break;
}
}
if(isExist){
return i-tempChars.length+1;
}
}
}
return -1;
}
public int lastIndexOf(String str){
return lastIndexOf(str, 0);
}
public String substring(int start,int end){
rangeCheck(start,end);
return String.valueOf(chars, start,end);
}
public String subString(int start){
return substring(start, capacity-1);
}
public char charAt(int index){
rangeCheck(index);
return chars[index];
}
public void setCharAt(int index,char ch){
rangeCheck(index);
chars[index] = ch;
}
public void replace(int start,int end,String str){
rangeCheck(start,end);
char[] tempChars = str.toCharArray();
char[] charsNew = growCapacity(capacity+tempChars.length+start-end);
if(charsNew == null){
for (int i = capacity - 1; i >= end; i--) {
chars[i + tempChars.length + start - end] = chars[i];
}
System.arraycopy(tempChars,0,chars,start,tempChars.length);
}else{
for(int i = capacity-1;i >= end;i--){
charsNew[i+tempChars.length+start-end] = chars[i];
}
System.arraycopy(tempChars,0,charsNew,start,tempChars.length);
chars = charsNew;
}
capacity += tempChars.length+start-end;
}
public void deleteCharAt(int index){
rangeCheck(index);
System.arraycopy(chars,index+1,chars,index,capacity-index-1);
capacity --;
}
public void delete(int start,int end){
rangeCheck(start,end);
System.arraycopy(chars,end+1,chars,start,capacity-end-1);//元素依次前移
capacity -= end-start+1;//更新容量值
}
@Override
public String toString(){//重写父类toString(方法)
return new String(chars,0,capacity);//返回一个String对象,利用String的构造方法
}
}