Java String类是灰常常用的一个类，但是天天在用，也没管过。
今天就来看看哪些是常用方法，然后了解一下其大概实现
然后希望达到的效果是：
自从看了我的这个字符串类，让你忘了你的她(他)。

关于字符串函数(split、join、indexOf、substring)，这些常用的方法可参考下链接;虽然总结的是js的，但是一样的，join是java 1.8d的

字符串函数(split、join、indexOf、substring)

估计看到那么多代码，新手都不想看了，先给个概览图先，如下：

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