自定义MyBuffer

package 数字与字符.Test01StringBuffer;

public class MyStringBuffer implements IStringBuffer {

    char [] cs;

    private int index = 0;  // cs的索引号
    // 默认构造
    public MyStringBuffer() {
        cs = new char[16]; // 默认容量16
    }
    // 带参构造
    public MyStringBuffer(String str){
        cs = str.toCharArray();
    }

    @Override
    public String toString() { // 重写toString方法
        return new String(cs);
    }
    // 在末尾加字符串
    @Override
    public void append(String str) {
        // 判断cs容量够否，不够就扩容，一直扩容到够为止
        while (cs.length - getCharNull(cs)  < str.length()){  
            //getCharNull 方法是返回字符数组第一个为空的索引
            cs = expendArr(cs);  // 调用扩容方法，返回字符数组，参数字符数组
        }
        index = getCharNull(cs);
        char[] addCs = str.toCharArray();
        //  增加字符串
        for (int i = 0;i < str.length(); index++, i++) {
                cs[index] = addCs[i];
        }

    }
//  在末尾添加字符
    @Override
    public void append(char c) {
        cs = expendArr(cs, 1); //  调用方法 传递参数cs字符数组，1为扩容增加的大小
        cs[cs.length - 1] = c;  // 添加c字符到字符数组末尾
    }

    @Override
    public void insert(int pos, char b) {    // pos这里没有判断，所以已知bug：pos不能大于最大索引
        // 增加容量大小为1
        cs = expendArr(cs, 1);
        // 将pos位置的字符依次向后移动1位
        for (int j = 1; j < cs.length - pos ; j++) {
            cs[cs.length - j] = cs[cs.length - j - 1];
        }
        // 插入字符
        cs[pos] = b;

    }

    @Override
    public void insert(int pos, String b) {
        // 增加容量
        cs = expendArr(cs, b.length());
//      字符在数组中向后移动一定长度
        for (int i = 1; i < cs.length - pos - b.length() + 1; i++) {
            cs[cs.length - i] = cs[cs.length - i - b.length()];
        }
//      临时字符数组
        char[] cs_Tmp = b.toCharArray();
        // 添加字符到指定位置
        for (int i = 0; i < b.length(); pos++, i++) {
            cs[pos] = cs_Tmp[i];
        }
    }

    @Override
    public void delete(int start) {
        // 调用删除方法，返回删除后的字符数组
        cs = deleteArr(cs, start);
    }

    @Override
    public void delete(int start, int end) {
        
        cs = deleteArr(cs, start, end);
    }

    @Override
    public void reverse() {
        
        index = cs.length -1;
       char[] chars = new char[cs.length];
       
        for (int i = 0; i < cs.length; i++) {
            chars[i] = cs[index--];
        }
        cs = chars;
    }
// 返回已经存储的容量
    @Override
    public int length() {
        return cs.length;
    }
    // 得到空字符的位置
    private int getCharNull(char[] cs){

        for (int i = 0; i < cs.length; i++) {
            if(cs[i] == '\u0000'){
                return i;
            }
        }
        return cs.length; // 没有就返回原始长度
    }
    // 扩容方法
    private char[] expendArr(char[] cs){

        char[] cs1 = new char[cs.length * 2];

        for (int i = 0; i < cs.length; i++) {
            cs1[i] = cs[i];
        }
        return cs1;
    }
    // 指定大小的扩容
    private char[] expendArr(char[] cs, int i){

        char[] cs1 = new char[cs.length + i];

        for (int j = 0; j < cs.length; j++) {
            cs1[j] = cs[j];
        }
        return cs1;
    }
    
    private char[] deleteArr(char[] cs, int i){

        char[] cs1 = new char[i+1];

        for (int j = 0; j < cs1.length; j++) {
            cs1[j] = cs[j];
        }
        return cs1;
    }
    private char[] deleteArr(char[] cs, int start, int end){

        char[] cs1 = new char[end - start + 1];

        for (int j = 0; j < cs1.length; j++, start++) {
            cs1[j] = cs[start];
        }
        return cs1;
    }
}

**总结：**1.对细节把握要牢固
2.数组传递的是地址