package j2se;


import java.util.Arrays;

public final class MyStringBufferPro implements IStringBuffer {
	private int LastIndex;
	private char[]data;
	private int memoryLength = 19;
	public MyStringBufferPro()
	{
		LastIndex = 0;
		data = new char[memoryLength];
	}	
	public MyStringBufferPro(String str)
	{
		data = str.toCharArray();
		LastIndex = str.length();
	}
	public MyStringBufferPro(char c)
	{
		LastIndex = 0;
		data = new char[memoryLength];
		append(c);
	}
	public MyStringBufferPro(int memoryLength)
	{
		this();
		this.memoryLength = memoryLength;
	}
	@Override
	public void append(String str) {
		// TODO Auto-generated method stub
		insert(LastIndex,str);
	}

	@Override
	public void append(char c) {
		// TODO Auto-generated method stub
		checkSpaceEnough(1);
		data[LastIndex] = c;
		moveNext();
	}
	public void append(char[] cs) {
		if(cs==null)return;
		// TODO Auto-generated method stub
		for (char c : cs) {
			append(c);
		}
	}
	private void moveNext()
	{
		LastIndex++;
		checkSpaceEnough(1);
	}
	@Override
	public void append(String... strs) {
		// TODO Auto-generated method stub
		for (String str : strs) {
			append(str);
		}
	}

	@Override
	public void insert(int pos, char c) {
		// TODO Auto-generated method stub
		insert(pos,String.valueOf(c));

	}

	@Override
	//核心方法，插入功能
	public void insert(int pos, String str) {
		if(checkIndexValid(pos))return;
		int leng = str.length();
		checkSpaceEnough(leng);  //检查内存是否足够
		int l = data.length;
		System.arraycopy(data, pos, data, pos+leng, LastIndex-pos);  //插入点后数据整体右移
		char[]cs = str.toCharArray();
		System.arraycopy(cs, 0, data, pos, cs.length);  //插入字符串
		LastIndex+=leng;
	}
	private boolean checkIndexValid(int id)
	{
		if(id<0||id>data.length-1)return false;
		return false;
	}
	private void checkSpaceEnough(int addLength)//检查内存是否足够，不够则扩充内存
	{
		if(LastIndex+addLength>data.length)
		{
			int multiply = 1+(LastIndex+addLength+1)/memoryLength;
			memoryLength = multiply*memoryLength;
			char[]temps = new char[memoryLength];
			int l = temps.length;
			System.arraycopy(data, 0,temps, 0, LastIndex);
			data = temps;
		}
		
	}
	@Override
	public void delete(int start) {
		// TODO Auto-generated method stub  Arrays.copyOfRange(data, 0, start);
		char[]head = new char[memoryLength*(int)Math.ceil((float)(start+1)/memoryLength)];
		System.arraycopy(data, 0, head, 0, start);
		data = head;
		LastIndex = start;
	}
	@Override
	public void delete(int start, int end) {
		// TODO Auto-generated method stub
		char[]head = new char[memoryLength*(int)Math.ceil((float)(1+start+LastIndex-end+1)/memoryLength)];
		System.arraycopy(data, 0, head, 0, start);
		if(end<LastIndex-1)
		System.arraycopy(data, end+1, head, start, LastIndex-end-1);
		data = head;
		LastIndex = start+LastIndex-end-1;
		
	}
	public void clear()
	{
		data = new char[data.length];
		LastIndex = 0;
	}
	@Override
	public void reverse() {
		// TODO Auto-generated method stub
		char[]temp = Arrays.copyOfRange(data, 0, LastIndex);
		for (int i = temp.length-1; i >= 0; i--) {
			data[i] = temp[temp.length-1-i];
		}
	}

	@Override
	public int length() {
		// TODO Auto-generated method stub
		return this.data.length;
	}
	@Override
	public String toString()
	{
		char[]arr = Arrays.copyOfRange(data, 0, LastIndex);
		return new String(arr);
	}

}

无异常

package com.zyl.java.day6.numbers;

import java.util.Arrays;

public class MyStringBuffer implements IStringBuffer{

    private char[] chars;
    private int capacity = 19;
    private int length = 0;

    public MyStringBuffer(){
        this.chars = new char[capacity];
    }

    public MyStringBuffer(String str){
        //扩容
        if(str.length()>this.capacity){
            this.capacity = (int)(str.length()*1.5f);
        }
        this.chars = new char[capacity];
        char[] strChars = str.toCharArray();
        this.length = str.length();
        System.arraycopy(strChars,0,strChars,0,length);
    }
    //扩容
    private void isCapacityLength(int strLength){
        if(strLength>this.capacity){
            this.capacity = (int)(strLength*1.5f);
            char[] newChars = new char[capacity];
            System.arraycopy(this.chars,0,newChars,0,length);
            this.chars = newChars;
        }
    }

    @Override
    public void append(String str) {
        insert(this.length,str);
    }

    @Override
    public void append(char c) {
        insert(this.length,""+c);
    }

    @Override
    public void insert(int pos, char b) {
        insert(pos,""+b);
    }

    @Override
    public void insert(int pos, String b) {
        //判断插入的位置是否有效
        if(pos < 0 || pos > length){
            return;
        }
        //查看是否需要扩容
        isCapacityLength(b.length()+this.length);

        //先把原有的复制到后面去
        System.arraycopy(this.chars,pos,this.chars,pos+b.length(),length-pos);
        //再把数据插入
        System.arraycopy(b.toCharArray(),0,this.chars,pos,b.length());

        this.length = length+b.length();
    }

    @Override
    public void delete(int start) {
        delete(start,length);
    }

    @Override
    public void delete(int start, int end) {
        //判断start,end是否有效
        if(start<0 || start>this.length){
            return;
        }
        if(end<0 || end>this.length){
            return;
        }
        if(end-start<0){
            return;
        }
        System.arraycopy(this.chars,end,this.chars,start,length-end);
        this.length = this.length-(end-start);
    }

    @Override
    public void reverse() {
        //反转
        for (int i = 0; i < this.length; i++) {
            if(i > this.length-i-1){
                return;
            }
            char temp = this.chars[i];
            this.chars[i] = this.chars[this.length-i-1];
            this.chars[this.length-i-1] = temp;
        }
    }

    @Override
    public int length() {
        return this.length;
    }

    public String toStringMsg() {
        return "MyStringBuffer{" +
                "chars=" + Arrays.toString(chars) +
                ", capacity=" + capacity +
                ", length=" + length +
                '}';
    }

    @Override
    public String toString() {
        return String.valueOf(chars,0,this.length);
    }

    public static void main(String[] args){
//        MyStringBuffer myStringBuffer = new MyStringBuffer();

//        myStringBuffer.append("1234567");
//        myStringBuffer.insert(1,"abc");
//        System.out.println(myStringBuffer);
//
////        myStringBuffer.delete(3,4);
//        myStringBuffer.delete(3);
//        System.out.println(myStringBuffer.toStringMsg());
//        System.out.println(myStringBuffer);

//        myStringBuffer.reverse();
//        System.out.println(myStringBuffer);


//        使用Java自带的 StringBuffer 和 这个我们自己开发的MyStringBuffer性能比较。
//        参考比较方案:
//        1. 生成长度是10的随机字符串
//        2. 使用StringBuffer追加1000000次统计时间
//        3. 使用MyStringBuffer追加1000000次统计时间
//
//        性能统计办法 参考 比较StringBuffer和String的性能
//        如果追加的次数太大，会导致内存不够使用(默认情况下是分配16m)，你会看到OutOfMemoryError 这样的错误。 调整的方式参考 JVM调试与设置 设置最大内存
//

        MyStringBuffer myStringBuffer = new MyStringBuffer();
        long start1 = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            myStringBuffer.append(StringTest.randomString(10));
        }
        System.out.println("MyStringBuffer用时："+(System.currentTimeMillis()-start1)+"毫秒");

        StringBuffer StringBuffer = new StringBuffer();
        long start2 = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            StringBuffer.append(StringTest.randomString(10));
        }
        System.out.println("StringBuffer用时："+(System.currentTimeMillis()-start2)+"毫秒");
    }
}
public class StringTest {
public static String randomString(int stringLength){
//        创建一个长度是5的随机字符串，随机字符有可能是数字，大写字母或者小写字母
//        给点提示: 数字和字符之间可以通过互相转换
//        char c = 'A';
//        short s = (short) c;
//        通过这个手段就能够知道字符 a-z A-Z 0-9 所对应的数字的区间了
//                          97-122 65-90 48-57

        Random random = new Random();
//        int i = random.nextInt(26) + 97;
//        int i2 = random.nextInt(26) + 65;
//        int i3 = random.nextInt(10) + 48;
        char[] chars = new char[stringLength];
        for (int j = 0; j < chars.length; j++) {
            int i1=0;
            if(j==0){
                i1 = random.nextInt(2);
            }else{
                i1 = random.nextInt(3);
            }

            if(i1==0){
                //小写
                chars[j] = (char)( random.nextInt(26) + 97);
            }else if(i1==1){
                //大写
                chars[j] = (char)( random.nextInt(26) + 65);
            }else if(i1==2){
                //数字
                chars[j] = (char)( random.nextInt(10) + 48);
            }
        }
//        System.out.println(new String(chars));
        return new String(chars);
    }
}

package digit;

public class Guancha { 
    public static void main(String[] args) {
       int total =10000;
       String s =randomString(10);
       System.out.println(s);
       StringBuffer sb =new StringBuffer();
        
       String str1 ="";
       long start =System.currentTimeMillis();
       
       for(int i=0;i<total;i++){
    	   str1=str1+s;
       }
       long end =System.currentTimeMillis();
       System.out.printf("使用字符串连接+的方式，连接%D次，耗时%d毫秒%n",total,end-start);
       total*=100;
       start =System.currentTimeMillis();
       for(int i=0;i<total;i++){
    	   sb.append(s);
       }
       end =System.currentTimeMillis();
       System.out.printf("使用字符串连接+的方式，连接%D次，耗时%d毫秒%n",total,end-start);
       }
    	 private static String randomString(int length) {
    		 char cs[]=new char[5];
  	       short end ='z'+1;
  	       short start='0';
  	       for(int i=0;i<cs.length;i++){
  	    	   while(true){
  	    		   char c =(char)(Math.random()*(end - start)+start);
  	    		   if(Character.isLetter(c)||Character.isDigit(c)){
  	    			   cs[i]=c;
  	    			   break;
  	    		   }
  	    	   }
  	       }
  	       String result=new String(cs);
  	       return result;
    }
}

ktGKn
Exception in thread "main" java.util.UnknownFormatConversionException: Conversion = 'D'
	at java.util.Formatter$FormatSpecifier.conversion(Formatter.java:2691)
	at java.util.Formatter$FormatSpecifier.<init>(Formatter.java:2720)
	at java.util.Formatter.parse(Formatter.java:2560)
	at java.util.Formatter.format(Formatter.java:2501)
	at java.io.PrintStream.format(PrintStream.java:970)
	at java.io.PrintStream.printf(PrintStream.java:871)
	at digit.Guancha.main(Guancha.java:17)

public class MyStringBuffer implements InterfaceStringBuffer {
    private char[] ch; //内部管理的个字符数组
    private int len; // 全局都要使用的数组内有效元素的个数

    public MyStringBuffer() {
        ch = new char[16];//创建对象要默认创建一个大小16的空数组
    }

    public MyStringBuffer(String str) {
        ch = new char[16];
        append(str);//当创建对象时传递了一个字符串，则调用内部的append去添加
    }

    @Override
    public void append(String str) {
        insert(len,str);
    }

    @Override
    public void append(char c) {
        insert(len,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 || pos>len){
            return;
        }
        char[] c = b.toCharArray();
        char[] temp = new char[capacity()];
        while (len+c.length > temp.length){//一步一步扩容
            temp = new char[temp.length*2 + 2];//原数组要进行扩容
        }
        System.arraycopy(ch, 0, temp, 0, pos);
        System.arraycopy(c, 0, temp, pos, c.length);
        System.arraycopy(ch, pos, temp, pos + c.length, len - pos);
        ch = temp;
        len = len + b.length();
    }

    @Override
    public void delete(int start) {
        delete(start,len);

    }

    @Override
    public void delete(int start, int end) {
        /*
         * 总体思想就是清零ch数组
         * 再把删除后的数组元素一个一个append进去
         * 这样可以避免过分关注ch数组大小和有效元素的问题
         * 全部由append去处理，最终还是由insert处理
         * 所以insert一定要写全面一点
         */
        if (end - start <= 0) {
            return;
        }
        if (start < 0) {
            return;
        }
        if (end > len) {
            return;
        }
        char[] temp = ch; //把ch数组缓存
        ch = new char[16];//ch数组清零
        int lentemp = len;//长度缓存，到时循环时需要用到
        len = 0;//ch都清零了，配套的len也得清零
        for (int i = 0; i < start; i++) {
            append(temp[i]);
        }
        for (int i = end; i < lentemp; i++) {
            append(temp[i]);
        }
    }
    @Override
    public void reverse() {
        char[] temp = new char[capacity()];
        for (int i = 0; i < len; i++) {
            System.arraycopy(ch, i, temp, len - 1 - i, 1);
        }
        ch = temp;

    }

    @Override
    public int length() {
        return len;
    }

    public int capacity() {

        return ch.length;
    }

    public String toString() {
        char[] temp = new char[len];
        System.arraycopy(ch, 0, temp, 0, len);//避免打印后字符串后面有很多空字符
        return String.valueOf(temp);
    }
}