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);
    }
}