模拟并实现Strings类部分功能

package mystring;
import java.util.Arrays;
/**
 模拟String类,自行设计一个MyStrings的字符串类
 */

public final class MyStrings implements Comparable<MyStrings>{

    private final char[] value;
    /*
    无参构造函数的情形视为传入长度为0的char数组，默认值为空
     */
    MyStrings(){
        this(new char[0]);
    }
    MyStrings(char[] value){
        this.value = value;
    }



    /*
    鉴于安全性（线程安全）和效率（从字符串常量池中提数据只需要复制地址）考虑
    我们设计的字符串是不可变类型@privae @final
    而我们操作字符串的办法就是 新建一个char数组拷贝里面信息，在对这个数组进行相应操纵
    最后将这个数组变为MyStrings对象返回。
    再者，每一种操作都拷贝这个过程，所以我们抽出拷贝的这个过程封装为一个私有函数方便来减少代码冗余。
     */
    private char[] Copy(){
        char[] chrs = new char[value.length];
        for (int i = 0;i < value.length;i++){
            chrs[i] = value[i];
        }
        return chrs;
    }
    /*
    只需要传入角标，访问一下私有变量value中对应角标的值，然后返回即可。
    */
    public char charAt(int index){
        return value[index];
    }
    public void catValue(){
        System.out.print("\"");
        for(int i = 0;i < value.length ;i++){
            System.out.print(value[i]);
        }
        System.out.print("\"");
    }
    /*
    创建一个新数组赋值原来的值，然后将其中的小写转化为大写
     */
    public MyStrings toUpperCase(){
        char[] upper = Copy();
        for(int i = 0;i < upper.length; i++){
            if(upper[i] >= 'a' && upper[i] <= 'z'){
                upper[i] = (char)(upper[i] + 'A' - 'a');
            }
        }
        return new MyStrings(upper);
    }
    /*
    创建一个新数组赋值原来的值，然后将其中的大写转化为小写
     */
    public MyStrings toLowerCase(){
        char[] lower = Copy();
        for(int i = 0;i < lower.length; i++){
            if(lower[i] >= 'A' && lower[i] <= 'Z'){
                lower[i] = (char)(lower[i] + 'a' - 'A');
            }
        }
        return new MyStrings(lower);
    }
    /*
    截取子串 及其无参、单参下的重载
     */
    public MyStrings substring(int startIndex,int stopIndex){
        char[] subchar = new char[stopIndex-startIndex];
        for(int i = 0;i < subchar.length;i++){
            subchar[i] = value[startIndex++];
        }
        return new MyStrings(subchar);
    }
    public MyStrings substring(){
        return substring(0 , this.value.length);
    }
    public MyStrings substring(int startIndex){
        return substring(startIndex , this.value.length);
    }
    /*
    判断当前MyStrings对象是否包含传入的MyStrings对象
     */
    public boolean contains(MyStrings ms){
        char[] v1 = this.value;
        char[] v2 = ms.value;
        for(int i = 0;i < value.length-ms.value.length-1;i++){
            for(int j = 0;j< ms.value.length;j++)
                if(v1[i]==v2[0]){
                    if(this.compareTo(ms) == 0){
                        return true;
                    }
                }
        }
        return false;
    }
    /**
     此方法从ComparaTo中继承而来
     可以比较MyStrings对象的大小
     @param ms 对比的目标
     @return int 整数
             ==0 表示对象和对比目标相同
             >=0 表示对象比对比目标大
             <=0 表示对象比对比目标小
     @Override
     内容不同时输出 最后一个不同的差值
     内容相同 而 有一方较长时 输出长度插值
     */
    public int compareTo(MyStrings ms){
        int len1 = this.value.length;
        int len2 = ms.value.length;
        int min = Math.min(len1,len2);
        for(int i = 0;i < min;i++){
            if(this.value[i] != ms.value[i]){
                return this.value[i] - ms.value[i];
            }
        }
        return 0;
    }
    public int compareToIgnoreCase(MyStrings ms){
        return this.toLowerCase().compareTo(ms.toLowerCase());
    }
    /*
    该字符串开头和结尾是否和传入的相匹配匹配
     */
    public boolean startsWith(MyStrings ms){
        return this.substring(0,ms.value.length).compareTo(ms) == 0;
    }
    public boolean endsWith(MyStrings ms){
        int start = this.value.length - ms.value.length;
        MyStrings end = this.substring(start);
        return end.compareTo(ms) == 0;
    }
}