MyStringBuffer-插入insert 和 append

边界条件判断
插入之前，首先要判断的是一些边界条件。 比如插入位置是否合法，插入的字符串是否为空

扩容

1. 要判断是否需要扩容。 如果插入的字符串加上已经存在的内容的总长度超过了容量，那么就需要扩容。
2. 数组的长度是固定的，不能改变的，数组本身不支持扩容。 我们使用变通的方式来解决这个问题。
3. 根据需要插入的字符串的长度和已经存在的内容的长度，计算出一个新的容量。 然后根据这个容量，创建一个新的数组，接着把原来的数组的内容，复制到这个新的数组中来。并且让value这个引用，指向新的数组，从而达到扩容的效果。

插入字符串
5. 找到要插入字符串的位置，从这个位置开始，把原数据看成两段，把后半段向后挪动一个距离，这个距离刚好是插入字符串的长度
6. 然后把要插入的数据，插入这个挪出来的，刚刚好的位置里。

修改length的值
最后修改length的值，是原来的值加上插入字符串的长度

insert(int, char)
参数是字符的insert方法，通过调用insert(int, String) 也就实现了。

append
追加，就是在最后位置插入。 所以不需要单独开发方法，直接调用insert方法，就能达到最后位置插入的效果

public class MyStringBuffer4 implements IStringBuffer {
	
	int capacity = 16;
    int length = 0;
    char[] value;//声明一个数组value,未初始化
    public MyStringBuffer4(){
        value = new char[capacity];
    }
      
    //有参构造方法
    public MyStringBuffer4(String str){
        this();
        if(null==str)
            return;
          
        if(capacity<str.length()){//判断初始容量和初始化的字符串的大小，根据实际情况进行扩容，然后才能顺利创建字符串对象
            capacity  = value.length*2;
            value=new char[capacity];
        }
          
        if(capacity>=str.length())//如果容量够了，就将这个字符串转成字符数组然后复制给value数组
            System.arraycopy(str.toCharArray(), 0, value, 0, str.length());
          
        length = str.length();
          
    }
    
	
	@Override
	public void append(String str) {
		// 追加，就是在最后位置插入。 所以不需要单独开发方法，直接调用insert方法，就能达到最后位置插入的效果
		insert(length,str);
		
	}

	@Override
	public void append(char c) {
		append(String.valueOf(c));
		
	}

	@Override
	public void insert(int pos, char b) {
		insert(pos,String.valueOf(b));
		
	}

	@Override
	public void insert(int pos, String b) {
		//边界条件判断
		//判断插入位置是否合法，插入的字符串是否为空
        if(pos<0)
            return;
          
        if(pos>length)
            return;
          
        if(null==b)
            return;
          
        //扩容
        /*
         * 1. 要判断是否需要扩容。 如果插入的字符串加上已经存在的内容的总长度超过了容量，那么就需要扩容。
		   2. 数组的长度是固定的，不能改变的，数组本身不支持扩容。 我们使用变通的方式来解决这个问题。
		   3. 根据需要插入的字符串的长度和已经存在的内容的长度，计算出一个新的容量。 然后根据这个容量，创建一个新的数组，接着把原来的数组的内容，复制到这个新的数组中来。
				并且让value这个引用，指向新的数组，从而达到扩容的效果。
         */
        while(length+b.length()>capacity){
            capacity = (int) ((length+b.length())*1.5f);//根据需要插入的字符串的长度和已经存在的内容的长度，计算出一个新的容量
            char[] newValue = new char[capacity];//然后根据这个容量，创建一个新的数组
            System.arraycopy(value, 0, newValue, 0, length);//接着把原来的数组的内容，复制到这个新的数组中来
            value = newValue;//并且让value这个引用，指向新的数组，从而达到扩容的效果
        }
          
        char[] cs = b.toCharArray();//将字符串b转成字符数组的形式
          
        //先把已经存在的数据往后移
        //找到要插入字符串的位置，从这个位置开始，把原数据看成两段，把后半段向后挪动一个距离，这个距离刚好是插入字符串的长度
          System.arraycopy(value, pos, value,pos+ cs.length, length-pos);
          
          
        //把要插入的数据插入到指定位置
          //然后把要插入的数据，插入这个挪出来的，刚刚好的位置里。
        System.arraycopy(cs, 0, value, pos, cs.length);
          
        length = length+cs.length;
          
    }
		
	

	@Override
	public void delete(int start) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void delete(int start, int end) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void reverse() {
		 for (int i = 0; i < length/2; i++) {
	            char temp = value[i];
	            value[i] = value[length-i-1];
	            value[length-i-1] = temp;
	        }
		
	}

	@Override
	public int length() {
		// TODO Auto-generated method stub
		return length;
	}

	
	 public String toString(){
         
	        char[] realValue = new char[length];
	  
	        System.arraycopy(value, 0, realValue, 0, length);
	          
	        return new String(realValue);
	          
	    }
	public static void main(String[] args) {
		MyStringBuffer4 sb = new MyStringBuffer4("there light");
        System.out.println(sb);
        sb.insert(0, "let ");
        System.out.println(sb);
  
        sb.insert(10, "be ");
        System.out.println(sb);
        sb.insert(0, "God Say:");
        System.out.println(sb);
        sb.append("!");
        System.out.println(sb);
        sb.append('?');
        System.out.println(sb);
        sb.reverse();
        System.out.println(sb);

	}

}