Java String類是灰常常用的一個類，但是天天在用，也沒管過。
今天就來看看哪些是常用方法，然後瞭解一下其大概實現
然後希望達到的效果是：
自從看了我的這個字串類，讓你忘了你的她(他)。

關於字串函式(split、join、indexOf、substring)，這些常用的方法可參考下連結;雖然總結的是js的，但是一樣的，join是java 1.8d的

估計看到那麼多程式碼，新手都不想看了，先給個概覽圖先，如下：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    /**
     * The value is used for character storage.
     */
    private final char value[];
    ...
	...
	...
    public int length() {
        return value.length;//字串長度就是這麼來的，陣列的長度。這下帶不帶括號的問題就明瞭啦.
    }

    public boolean isEmpty() {
        return value.length == 0;
    }

    public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }
	
	//"AAA"和"aaa" 走這個方法的返回結果是false
    public boolean equals(Object anObject) {
        //內部實現就是,先判斷型別,再判斷陣列長度,相等了再繼續
		//迴圈2個數組，逐個比較，不等就返回false，要麼最後返回true。
		//新手注意：ss.equals("AAA");//ss可能為null。
		//          "AAA".equals(ss);//正確姿勢。
    }
	
	//"AAA"和"aaa" 走這個方法的返回結果是true
    public boolean equalsIgnoreCase(String anotherString) {
        //內部實現判斷不等null，長度相等，再繼續
		//也是迴圈2個數組,先都轉大寫，比較之後相等，就繼續下次迴圈
		//要是意外不等,再都轉小寫，再比較，都失敗的話，就不等啦。
    }
	
	//是否以prefix 開頭
    public boolean startsWith(String prefix, int toffset) {
	//都是迴圈陣列挨個比較
    }
    public boolean startsWith(String prefix) {
        return startsWith(prefix, 0);
    }
    public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }

	//返回在字串中的位置，也就是陣列的下標
    public int indexOf(String str) {
        return indexOf(str, 0);
    }
    public int lastIndexOf(String str) {
        return lastIndexOf(str, value.length);
    }

	//字串擷取
    public String substring(int beginIndex) {
    }

	//在原字串後面串聯上個str
    public String concat(String str) {
    }

	//替換字串中的值 oldChar--->newChar
    public String replace(char oldChar, char newChar) {
    }

	//是否包含 s
    public boolean contains(CharSequence s) {
    }

	//將字串以regex為標誌，擷取，返回個數組,不含標誌位regex
    public String[] split(String regex) {
    }

	//全部轉小寫
    public String toLowerCase() {
        return toLowerCase(Locale.getDefault());
    }

	//全部轉大寫
    public String toUpperCase() {
        return toUpperCase(Locale.getDefault());
    }

	//去掉首尾的多餘空格
    public String trim() {
    }

    //static 直接類呼叫的方法
	// 將幾個字串合併成一個返回
    public static String join(CharSequence delimiter, CharSequence... elements) {
    } //Java 1.8 才有的這個方法，

	//有很多過載(方法名相同，引數列表不同)
	//引數可以是幾個基本資料型別：int,long,float,double,char,boolean,
	//基本資料型別是沒有方法可言的，所以對應的封裝型別才有方法，Integer,Long,Float,Double
    public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }
    public static String valueOf(long l) {
        return Long.toString(l);
    }
	...
    public static String valueOf(char c) {
        char data[] = {c};
        return new String(data, true);
    }
    public static String valueOf(boolean b) {
        return b ? "true" : "false";
    }
	
}	
 

	//正兒八經的String的equal方法如下：就是挨個比較2個數組的值而已。
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }