/**
  * 輸出分隔后的字符數(shù)組
  * 為了可以明顯的看出空字符串的輸出，如遇空字符串則輸出為——“空字符串”
  * @param split
  */
    private void printSplit(String[] split) {
        for (String temp : split) {
            //空字符串的話輸出--“空字符串”
            if (temp.equals("")) {
                System.out.println("空字符串");
            } else {
                System.out.println(temp);
            }
        }
    }

	/**
     * 基礎(chǔ)使用1：單個字符-:
     */
    @Test
    public void Test1() {
        string = "boo:and:foo";
        String[] split = string.split(":");
        printSplit(split);
    }

    /**
     * 基礎(chǔ)使用1：單個字符-o
     */
    @Test
    public void Test2() {
        string = "boo:and:foo";
        String[] split = string.split("o");
        printSplit(split);
    }

/**
  * 基礎(chǔ)使用2：正則表達(dá)式-1
  */
    @Test
    public void Test3() {
        string = "asd-sdf+sda+sda";
		//匹配-或者+
        String[] split = string.split("[-\\+]");
        printSplit(split);
    }

/**
  * 基礎(chǔ)使用2：正則表達(dá)式-2
  */
    @Test
    public void Test4() {
        string = "boo1:a2nd:fo3o";
		//匹配正整數(shù)
        String[] split = string.split("[0-9]*[1-9][0-9]*");
        printSplit(split);
    }

/**
* 單個參數(shù)的方法其實就是調(diào)用了雙參數(shù)的方法，第二個參數(shù)limit為0
*/
public String[] split(String regex) {
	return split(regex, 0);
}

public String[] split(String regex, int limit) {
    
    /*英文轉(zhuǎn)譯：
    如果正則表達(dá)式是
    (1)一個字符的字符串，并且這個字符不是
    正則表達(dá)式的元字符".$|()[{^?* + \ \”,或
    (2)兩個字符的字符串，第一個字符是反斜杠和
    第二個不是ascii數(shù)字或ascii字母。*/
    
    //下面有對于if判斷的拆解，因為篇幅占位大，放到本段代碼末尾，建議先看   
    char ch = 0;
    if (((regex.value.length == 1 &&
          ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
         (regex.length() == 2 &&
          regex.charAt(0) == '\\' &&
          (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
          ((ch-'a')|('z'-ch)) < 0 &&
          ((ch-'A')|('Z'-ch)) < 0)) &&
        (ch < Character.MIN_HIGH_SURROGATE ||
         ch > Character.MAX_LOW_SURROGATE))
     //以上這一大片都是if判斷條件↑
    {
        //定義上一個字符串分割結(jié)束的位置，起始為0
        int off = 0;
   		//定義下一個分隔符在待分割字符串中的位置，，起始為0
        int next = 0;
        //boolean值，如果limit大于0為true ，小于等于0皆為false
        boolean limited = limit > 0;
        //定義分割后的字符串?dāng)?shù)組，因為String[]長度固定，不便于使用
        ArrayList<String> list = new ArrayList<>();
        
      /**
        * while判斷語句中做了兩件事：
        *	1）使用indexof查詢off以后下一個ch的位置，并賦值給next
        *	2）如果后續(xù)再找不到ch則退出循環(huán)
        *
        *if語句中也不簡單，首先看【 !limited 】
        *上面limited賦值中可知，如果limit大于0，則【!limited】恒為false
        *					如果limit不大于于0，則【!limited】恒為true
        *翻譯為“人話”就是：
        *   如果limit大于0則后續(xù)條件才需要判斷，否則if條件一直都是true
        *   進(jìn)一步推論，如果limit不大于0，則else里面的語句塊肯定不會執(zhí)行
        *
        *其次看看第二個條件，【list.size() < limit - 1】：list的長度小于limit-1
        *我們可以做出兩種假設(shè)：
        *	1）limit無限大，則這第二個條件一定恒為true
        *	2）limit很小，那么只有這種情況才會出現(xiàn)list長度會小于limit的情況，也就是false
        *	那么limit的分界線在哪呢？也就是limit的取值如何才會出現(xiàn)有false的情況
        *	決定性因素肯定就是 原字符串分割出多少子字符串：
        *	若limit是大于能分割出的子字符串，表達(dá)式一定為true
        *	若limit是小于能分割出的子字符串個數(shù)，那表達(dá)式【list.size()=limit-1】則為false，并且進(jìn)入else語句塊。
        *
        *將兩個條件整合到一起：也就是只有當(dāng)limit>0并且小于能分割出子字符串個數(shù)時
        *if才會出現(xiàn)false的情況，并且這時【list.size()=limit-1】，進(jìn)入else語句塊
        *
        *if{...}else{...}里面的語句塊就比較簡單了
        *	通過substring進(jìn)行分割字符串，并放入list中
        *	然后將off往后移動
        *	else內(nèi)的語句塊也是一樣的，不過添加的是最后一個子字符串
        */
        while ((next = indexOf(ch, off)) != -1) {
            if (!limited || list.size() < limit - 1) {
                list.add(substring(off, next));
                off = next + 1;
            } else {    // last one
                //assert (list.size() == limit - 1);
                list.add(substring(off, value.length));
                off = value.length;
                break;
            }
        }
        // If no match was found, return this
        //如果沒有找到匹配項，則返回this
        //off如果為0，那么就證明上述那個循環(huán)中并未找到匹配項
        if (off == 0)
            return new String[]{this};

        // Add remaining segment
        //添加剩余的部分
        //同上，當(dāng)limit不大于0的時候恒為true
        //只有l(wèi)imit>0而且list長度大于等于limit才為false
        //因為上面循環(huán)中l(wèi)ist.size()=limit-1，進(jìn)入else語句塊，語句塊中會再給list加入一個元素
        
        //可知，這個if判斷與上面else語句塊兩個互補(bǔ)，兩個不會同時運(yùn)行到
        //這個與else語句塊作用一致，都是將最后一個子字符串添加入list
        if (!limited || list.size() < limit)
            list.add(substring(off, value.length));

        // Construct result
        //構(gòu)建結(jié)果
        
        //如果limit為0，進(jìn)行特殊處理
        //首先字符串?dāng)?shù)組長度大于0并且獲取最后一個字符數(shù)組的字符串長度為0
        //簡而言之，前提條件字符數(shù)組長度得大于0（小于0還分割個啥）
        //其次尋找最后一個是否是空字符串，如果是，將長度減一，如果不是則退出循環(huán)
        int resultSize = list.size();
        if (limit == 0) {
            while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
                resultSize--;
            }
        }
        
        //定義字符數(shù)組，將list轉(zhuǎn)為String[]
        //因為后面空字符長度被去掉了，于是空字符被省略了
        String[] result = new String[resultSize];
        return list.subList(0, resultSize).toArray(result);
    }
    //如果不符合if的條件就進(jìn)入這個方法
    return Pattern.compile(regex).split(this, limit);
}

//if條件的拆分
 /*如果正則表達(dá)式是
    (1)一個字符的字符串，并且這個字符不是
    正則表達(dá)式的元字符".$|()[{^?* + \ \”,或
    (2)兩個字符的字符串，第一個字符是反斜杠和
    第二個不是ascii數(shù)字或ascii字母。*/
(
    (
        (
            regex.value.length == 1
            &&
            ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1
            //小細(xì)節(jié)，這里將ch賦值了，也就是將改字符賦值給了ch
        )
        ||
        (
            regex.length() == 2 
            &&
            regex.charAt(0) == '\\'
            &&
            (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0
            //小細(xì)節(jié)*2
            &&
            ((ch-'a')|('z'-ch)) < 0
            &&
            ((ch-'A')|('Z'-ch)) < 0
        )
    )
    &&
    (ch < Character.MIN_HIGH_SURROGATE ||ch > Character.MAX_LOW_SURROGATE)
)

    /**
     * 讀源碼：測試1，單個非特殊字符
     * 結(jié)果為并未調(diào)用Pattern.compile
     * if判斷條件結(jié)果為true
     */
    @Test
    public void Test5() {
        string = "boo:and:foo";
        String[] split = string.split(":");
        printSplit(split);
    }

    /**
     * 讀源碼：測試1，兩個字符，并且第一個字符為\第二個字符不為數(shù)字或者單詞
     * 結(jié)果為并未調(diào)用Pattern.compile
     * if判斷條件結(jié)果為true
     * 這里需要注意，雖然regex是為\\$但是其實在Java解讀中第一個為轉(zhuǎn)義字符
     * 所以傳到方法中其實代碼解讀為\$
     * 你們可以在調(diào)試的時候看一下這個入?yún)⒌闹当隳馨l(fā)現(xiàn)
     */
    @Test
    public void Test6() {
        string = "boo$and$foo";
        String[] split = string.split("\\$");
        printSplit(split);
    }

    /**
     * 讀源碼：測試3，三個字符
     * if判斷條件結(jié)果為false
     * 結(jié)果為調(diào)用了Pattern.compile
     */
    @Test
    public void Test7() {
        string = "boo:and:foo";
        String[] split = string.split("and");
        printSplit(split);
    }

    /**
     * limit參數(shù)區(qū)別：=0
     * 輸出全部結(jié)果，去除結(jié)果后面全部空字符數(shù)組
     */
    @Test
    public void Test8() {
        string = "boo:and:foo:::";
        String[] split = string.split(":", 0);
        printSplit(split);
    }

    /**
     * limit參數(shù)區(qū)別：<0
     * 輸出全部結(jié)果
     */
    @Test
    public void Test9() {
        string = "boo:and:foo:::";
        String[] split = string.split(":", -1);
        printSplit(split);
    }

    /**
     * limit參數(shù)區(qū)別：>0 --小于分割出的字符數(shù)組長度
     */
    @Test
    public void Test10() {
        string = "boo:and:foo";
        String[] split = string.split(":", 2);
        printSplit(split);
    }

    /**
     * limit參數(shù)區(qū)別：>0 --大于分割出的字符數(shù)組長度
     */
    @Test
    public void Test11() {
        string = "boo:and:foo";
        String[] split = string.split(":", 5);
        printSplit(split);
    }

    /**
     * 易錯點：分割到第一個字符
     */
    @Test
    public void Test12() {
        string = "boo$and$foo";
        String[] split = string.split("b", 0);
        printSplit(split);
    }

    /**
     * 易錯點：轉(zhuǎn)義字符\
     */
    @Test
    public void Test13() {
        //因為java代碼不能直接輸入一個反斜杠，必須進(jìn)行轉(zhuǎn)義，這里的\\表達(dá)為\
        string = "boo\\and\\foo";
        //這里\\\\應(yīng)該拆開看成為\\ \\,前面兩個代表一個\后面兩個代表一個\
        //實際\\\\表達(dá)的含義應(yīng)該為\\，對應(yīng)正則表達(dá)式的語法\\表達(dá)為\
        //所以在Java代碼中\(zhòng)\\\在最終處理時候其實表達(dá)為\
        String[] split = string.split("\\\\", 0);
        printSplit(split);
    }

    /**
     * 易錯點：轉(zhuǎn)義字符\
     */
    @Test
    public void Test14() {
        string = "boo+and-foo*boo";
        //這里的+-*都是正則表達(dá)式的元字符，都需要使用\轉(zhuǎn)義，然后在Java中再對\轉(zhuǎn)義
        //原正則表達(dá)式[\+\-\*]
        String[] split = string.split("[\\+\\-\\*]", 0);
        printSplit(split);
    }

    /**
     * 易錯點：正則表達(dá)式修飾符不可用
     * 理想輸出[(boo:),(nd:foo)]
     */
    @Test
    public void Test15() {
        string = "boo:and:foo";
        String[] split = string.split("/[a]/g", 0);
        printSplit(split);
    }