今天在使用split分割字符串时突然想到一种情况，如下：

String str="aaaaaaaab";
String arr[]=str.split("aa");

问，arr数组的长度是多少？
那如果str为”baaaaaaaa”呢

	String str="baaaaaaaa";

如果str=”aaaaaaaab”呢

String str="aaaaaaaab";

如果str=”baaaaaaaab”呢

String str="baaaaaaaab";

好，我们先在程序中验证一下：

public class Test {

	public static void main(String[] args) {
		String str="aaaaaaaa";
		String [] arr=str.split("aa");
		System.out.println("字符串aaaaaaaa分割的数组长度为："+arr.length);
		
		str="baaaaaaaa";
		arr=str.split("aa");
		System.out.println("字符串baaaaaaaa分割的数组长度为："+arr.length);
		
		str="aaaaaaaab";
		arr=str.split("aa");
		System.out.println("字符串aaaaaaaab分割的数组长度为："+arr.length);
		
		str="baaaaaaaab";
		arr=str.split("aa");
		System.out.println("字符串baaaaaaaab分割的数组长度为："+arr.length);

	}
}

运行以上代码输出结果

看到结果的你是不是有点小小的惊讶，如果有的话那就继续往下看。
通过split方法查看源码可知又调用了split(regex, 0)方法并且传入一个0：

  public String[] split(String regex) {
        return split(regex, 0);
    }

继续查看源码

 public String[] split(String regex, int limit) {
        /* fastpath if the regex is a
         (1)one-char String and this character is not one of the
            RegEx's meta characters ".$|()[{^?*+\\", or
         (2)two-char String and the first char is the backslash and
            the second is not the ascii digit or ascii letter.
         */
        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))
        {
            int off = 0;
            int next = 0;
            boolean limited = limit > 0;
            ArrayList<String> list = new ArrayList<>();
            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
            if (off == 0)
                return new String[]{this};

            // Add remaining segment
            if (!limited || list.size() < limit)
                list.add(substring(off, value.length));

            // Construct result
            int resultSize = list.size();
            if (limit == 0) {
                while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
                    resultSize--;
                }
            }
            String[] result = new String[resultSize];
            return list.subList(0, resultSize).toArray(result);
        }
        return Pattern.compile(regex).split(this, limit);
    }

有其中关系可知最终会执行 Pattern.compile(regex).split(this, limit)这一段代码，基础往下扒代码：

  public String[] split(CharSequence input, int limit) {
        int index = 0;
        boolean matchLimited = limit > 0;
        ArrayList<String> matchList = new ArrayList<>();
        Matcher m = matcher(input);

        // Add segments before each match found
        while(m.find()) {
            if (!matchLimited || matchList.size() < limit - 1) {
                if (index == 0 && index == m.start() && m.start() == m.end()) {
                    // no empty leading substring included for zero-width match
                    // at the beginning of the input char sequence.
                    continue;
                }
                String match = input.subSequence(index, m.start()).toString();
                matchList.add(match);
                index = m.end();
            } else if (matchList.size() == limit - 1) { // last one
                String match = input.subSequence(index,
                                                 input.length()).toString();
                matchList.add(match);
                index = m.end();
            }
        }

        // If no match was found, return this
        if (index == 0)
            return new String[] {input.toString()};

        // Add remaining segment
        if (!matchLimited || matchList.size() < limit)
            matchList.add(input.subSequence(index, input.length()).toString());

        // Construct result
        int resultSize = matchList.size();
        if (limit == 0)
            while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
                resultSize--;
        String[] result = new String[resultSize];
        return matchList.subList(0, resultSize).toArray(result);
    }

通过代码我们可以发现最终matchList集合中会有值，不过都是空值，然后在

  while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
                resultSize--;

这一段代码中，首先判断最后一个是不是空，如果没有值的话就减一位，依次类推，所以看到这大家对以上程序出现的结果是不是就不奇怪了。
所以我们可以大胆的总结一下，使用split方法分割字符串，如果最后几位是空的话，会将空的位置去掉。

加入我的行列：

（嘿嘿嘿，点击这里关于我哦，分享小知识）：https://www.jianshu.com/p/7d19f0df5b6b

1 String[] split(String regex)

将此字符串拆分为给定的regular expression(正则表达式)匹配
参数：regex–分割正则表达式
结果：将字符串按分隔符分为字符串数组。
注意：

1. 如果字符串中的regex后面字符也是regex，后面每有一个regex，字符串数组中就会在对应的位置多一个空字符串。但如果空字符串在末尾，字符串数组就会将它舍弃。

public class test {
    public static void main(String[] args) {
        String str = "1,,2,3,4,,,,";
        String[] s = str.split(",");
        for (String word : s) {
            System.out.println(word + "%");
        }
    }
}

从结果中我们可以看出第二个逗号作为空字符串在字符串数组中存在，而字符串str末尾的逗号都被舍弃。

2. 当regex为①( ②[ ③{ ④/ ⑤^ ⑥- ⑦$ ⑧¦ ⑨} ⑩] ⑪ ) ⑫? ⑬* ⑭+ ⑮.等这些特殊字符时，需要在前面加上\\进行转义。

public class test {
    public static void main(String[] args) {
        String str = "1..2.3.4....5.6...";
        String[] s = str.split("\\.");
        for (String word : s) {
            System.out.println(word + "%");
        }
    }
}

从上述结果可以看出.需要转义字符形成\\.才能对字符串分割。而且输出结果也验证了第一点regex后面的每个regex对应字符串数组中的空字符串，末尾的部分舍弃。

2 String[] split(String regex, int limit)

将此字符串拆分为给定的regular expression(正则表达式)匹配
参数：

1. regex–分割正则表达式；
2. limit–影响字符串数组的长度

• limit > 0 : regex的匹配模式将最多被应用limit - 1次，数组的长度不会超过limit，数组的最后一项有可能包含所有超出最后匹配的regex。
• limit = 0 : 与不带参数limit的split方法相同，结尾的空字符串被舍弃。
• limit < 0 : 匹配模式将尽可能多的使用，而且字符串数组可以是任意长度。
  结果：将字符串按分隔符分为字符串数组。

String str = "3..2.1.1....1.6...";

1. 当regex = "1"时，

public class test {
    public static void main(String[] args) {
        String str = "3**2*1*1****1*6***";
        int[] limitArr = {0, 2, 5, -2};
        for (int limit : limitArr) {
            String[] s = str.split("1", limit);
            System.out.println("limit = " + limit + " : " + Arrays.toString(s));
        }
    }
}

2. 当regex = "\\*"时，

public class test {
    public static void main(String[] args) {
        String str = "3**2*1*1****1*6***";
        int[] limitArr = {0, 2, 5, -2};
        for (int limit : limitArr) {
            String[] s = str.split("\\*", limit);
            System.out.println("limit = " + limit + " : " + Arrays.toString(s));
        }
    }
}

3 split()的应用

3.1 leetcode–1078. Bigram 分词

1078. Bigram 分词

这道题目很简单，直接上代码：

public String[] findOcurrences(String text, String first, String second) {
    List<String> res = new ArrayList<>();
    String[] words = text.split(" ");
    for (int i = 0; i < words.length - 2; i++) {
        if (words[i].equals(first) && words[i + 1].equals(second))
            res.add(words[i + 2]);
    }
    return res.toArray(new String[0]);
}

注意：

1. split方法字符串进行分割；
2. toArray(new String[0])将List转换为数组；

Python字符串–split方法

描述： 这是字符串的分隔方法，主要有两个参数。第一个参数是“指定分隔符对字符串进行分隔”，第二个参数是“指定分隔的段数”，在这里需要注意的是：分隔的段数是设置的参数+1.

示例一，分隔符默认为所有的空字符，包括空格符，换行符，制表符等

str1="i need to leave,i'd like to do some anything important"
print(str1.split())
str1="i\nneed\nto\nleave,i'd\nlike\nto\ndo\nsome\nanything\nimportant"
print(str1.split())
str1="i\tneed\tto\tleave,i'd\tlike\tto\tdo\tsome\tanything\timportant"
print(str1.split())
print(type(str1.split()))

运行结果如下：

['i', 'need', 'to', "leave,i'd", 'like', 'to', 'do', 'some', 'anything', 'important']
['i', 'need', 'to', "leave,i'd", 'like', 'to', 'do', 'some', 'anything', 'important']
['i', 'need', 'to', "leave,i'd", 'like', 'to', 'do', 'some', 'anything', 'important']
<class 'list'>

在这里需要注意的是返回值是一个字符串列表！

示例二，指定分隔符

str1="i need to leave,i'd like to do some anything important"
print(str1.split("i",1))
print(str1.split("need",1))
print(str1.split("i need to leave"))
str2="i i i i i i"
print(str2.split("i"))

运行结果如下：

['', " need to leave,i'd like to do some anything important"]
['i ', " to leave,i'd like to do some anything important"]
['', ",i'd like to do some anything important"]
['', ' ', ' ', ' ', ' ', ' ', '']

1.在这里需要注意的是，第二个参数可以不设，如果不设置参数的话，就如第四个例子一样，有多少个字符就分+1段。
2.第一个参数可以是一个句子或者一段话。

文 | 戴眼镜的it小孩纸