数据结构<十二>: 不可变的String实现

package com.mo.string;

/**
 *  根据串的抽象数据类型，应该有两种功能的串:
 *    一种要求是:任何对串的连接，插入子串和删除子串操作 都是 不改变原来串的值的
 *    另一种要求是: 任何对串的连接，插入子串和删除子串操作 都是 改变原来串的值
 *
 *  java中，String类是第一种功能的类，StringBuffer类是第二中功能的类
 *
 *  JDK的串类
 *    String类和StringBuffer类都是基于字符数组实现的，
 *    不同的是，String类的串一经创建，串的数值是无法改变的，即是一种状态不可变的对象
 *      而StringBuffer类的串创建后，串的值是可以改变的，因而StringBuffer类的对象的长度是可以改变的
 */
public class MyString {
  
  private char[] value;//字符数组
  private int count;//字符个数

  public MyString() {
    value = new char[0];
  }

  //对传进来的value字符数组分隔，取  value[offset] 到   value[offset+count]
  public MyString(char[] value,int offset,int count) {
    if(offset < 0) throw new StringIndexOutOfBoundsException();
    if(count > value.length - offset) throw new StringIndexOutOfBoundsException();
    if(count < 0) throw new StringIndexOutOfBoundsException();
    //创建一个空的字符数组
    this.value = new char[count];
    this.count = count;
    //将空的字符数组填满
    arrayCopy(value, offset, this.value, 0, count);
  }
  
  public MyString(char[] arr) {
    this.count = arr.length;
    //创建一个空的字符数组
    this.value = new char[count];
    //将参数传进来的arr，放到this.value中，因为这时候this.value还是空的
    arrayCopy(arr, 0, this.value, 0, count);
  }
  
  public MyString(String str) {
    char[] charArray = str.toCharArray();
    this.value = charArray;
    count = this.value.length;
  }
  
  /**
   * 复制数组 
   * @param src 原数组
   * @param srcPos 从原数组的srcPos下标开始复制，复制length个长度
   * @param dst 目标数组
   * @param dstPos 从目标数组的dstPos下标开始接受原数组的元素，接受length个长度
   * @param length 要复制原数组的长度
   */
  static void arrayCopy(char[] src,int srcPos,char[] dst,int dstPos,int length) {
    //这里是防止数组越界
    if(src.length - srcPos < length && dst.length - dstPos < length) throw new StringIndexOutOfBoundsException();
    for(int i = 0;i < length;i++) { 
      dst[dstPos] = src[srcPos];
      srcPos++;
      dstPos++;
    }
  }
  
  //取字符
  public char charAt(int index) {
    if(index < 0 || index > this.value.length) throw new StringIndexOutOfBoundsException();
    return this.value[index];
  }
  
  //取串的长度
  public int length() {
    return count;
  }
  
  //取子串
  public MyString subString(int begin,int end) {
    if(begin < 0 || end < 0 || end < begin || end > this.value.length) throw new StringIndexOutOfBoundsException();
    return new MyString(value,begin,end - begin);
  }
  
  //取子串，从begin一直到结束
  public MyString subString(int begin) {
    return subString(begin, count);
  }
  
  //并接字符串
  public MyString concat(MyString str) {
    int length = str.length();
    char[] array = str.toArray();
    //创建一个空的字符数组
    char[] newchar = new char[(length+count)];
    //将字符数组填满
    arrayCopy(this.value, 0, newchar, 0, count);
    arrayCopy(array, 0, newchar, count, length);
    return new MyString(newchar);
  }

  //插进子串，新增加的字符串str从原来的字符串pos位置添加
  public MyString insert(MyString str,int pos) {
    if(pos < 0 || pos > count) throw new StringIndexOutOfBoundsException();
    if(pos != 0) {
      MyString s1 = this.subString(0, pos);
      MyString s2 = this.subString(pos);
      MyString c1 = s1.concat(str);
      MyString c2 = c1.concat(s2);
      return c2;
    }else {
      return this.concat(str);
    }
  }

  //删除子串
  public MyString delete(int begin,int end) {
    if(end < begin || begin < 0 || end > count ) throw new StringIndexOutOfBoundsException();
    if(begin == 0 && end == 0) {
      return new MyString();
    }else {
      MyString s1 = this.subString(0, begin);
      MyString s2 = this.subString(end);
      return s1.concat(s2);
    }
  }
  
  //打印字符串
  public void myPrint() {
    for(int i = 0; i < count; i++) {
      System.out.print(value[i]);
    }
    System.out.println();
  }
  
  public char[] toArray() {
    //创建一个空的字符数组
    char[] buf = new char[count];
    //经过这一步就把新建的字符数组填满了
    arrayCopy(this.value, 0,buf ,0, count);
    return buf;
  }
  
  public static void main(String[] args) {
    char[] s1 = {'a','b','c','d','e','g'};
    char[] s2 = {'a','b','c','d','e','g','a','b','c','d','g','a','b','g','a','b'};
    
    MyString m1 = new MyString();
    m1.myPrint();

    MyString m2 = new MyString(s1);
    m2.myPrint();
    
    System.out.println("-------------");
  
    MyString m3 = new MyString(s2, 2, 7);
    m3.myPrint();
    System.out.println(m3.charAt(2));
    System.out.println(m3.length());
    System.out.println("end");

    System.out.println("-------------");
    
    MyString m4 = new MyString(s2);
    m4.myPrint();
    m4.subString((m4.length() - 3)).myPrint();
    
    m4.subString(0, 3).myPrint();
    
    System.out.println("------------------");
    
    MyString m5 = m4.subString(m4.length() - 3);
    MyString m6 = m4.subString(m4.length() - 4);
    m5.myPrint();
    m6.myPrint();
    MyString m7 = m5.insert(m6, 1);
    m7.delete(1, 3).myPrint();
  }
  
}