模擬並實現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;
    }
}