Java中String的split()方法的一些疑问和试验

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

 split函数是用于使用特定的切割符（regex）来分隔字符串成一个字符串数组，这里我就不讨论第二个参数（可选）的含义详见官方API说明

 

我在做项目期间曾经遇到一个“bug”，就是当split函数处理空字符串时，返回数组的数组竟然有值。。。查完API才发现就是这么规定的。

官方API 写道

If the expression does not match any part of the input then the resulting array has just one element, namely this string.

 原来我不能小看空字符串，它也是字符串的一种，当split函数没有发现匹配的分隔符时，返回数组就只包含一个元素（该字符串本身）。以为这样就结束了，幸亏我做了几个试验，忽然又发现了一些问题，代码如下：

public class Split {

	public static void main(String[] args) {
		String str1 = "a-b";		
		String str2 = "a-b-";
		String str3 = "-a-b";
		String str4 = "-a-b-";
		String str5 = "a";
		String str6 = "-";
		String str7 = "--";
		String str8 = "";	//等同于new String()
		
		getSplitLen(str1);
		getSplitLen(str2);
		getSplitLen(str3);
		getSplitLen(str4);
		getSplitLen(str5);
		getSplitLen(str6);
		getSplitLen(str7);
		getSplitLen(str8);
	}
	
	public static void getSplitLen(String demo){
		String[] array = demo.split("-");
		int len = array.length;
		System.out.print("\"" + demo + "\"长度为：" + len);
		if(len >= 0){
			for(int i=0; i<len; i++){
				System.out.print(" \""+array[i]+"\"");
			}			
		}
		System.out.println();
	}

}

 运行结果：

"a-b"长度为：2 "a" "b"
"a-b-"长度为：2 "a" "b"
"-a-b"长度为：3 "" "a" "b"
"-a-b-"长度为：3 "" "a" "b"
"a"长度为：1 "a"
"-"长度为：0
"--"长度为：0
""长度为：1 ""

 

和我想的还是不大一样，因为不知道源码也不知道具体是怎么实现的，我的理解如下：

1. 当字符串只包含分隔符时，返回数组没有元素；
2. 当字符串不包含分隔符时，返回数组只包含一个元素（该字符串本身）；
3. 字符串最尾部出现的分隔符可以看成不存在，不影响字符串的分隔；
4. 字符串最前端出现的分隔符将分隔出一个空字符串以及剩下的部分的正常分隔；

 

javascript也有split()函数，我想应该也是类似的，还没有来得及尝试。

评论

5 楼 xuxiaoyinliu 2015-12-09  

我也遇到这个问题了，感谢你的总结，很有帮助

4 楼 cuisuqiang 2012-05-03  

小问题，处理时判断即可

3 楼 jyjava 2012-05-02  

你可以在split之前进行indexof判读

2 楼 yuxuan1215 2012-05-02  

java中的实现是这样的
1.这个是String类里的split方法
public String[] split(String regex, int limit) {
return Pattern.compile(regex).split(this, limit);
    }

2Pattern.compile(regex)如下
public static Pattern compile(String regex) {
        return new Pattern(regex, 0);
    }
3上一步new pattern
private Pattern(String p, int f) {
        pattern = p;
        flags = f;

        // Reset group index count
        capturingGroupCount = 1;
        localCount = 0;

        if (pattern.length() > 0) {
            compile();
        } else {
            root = new Start(lastAccept);
            matchRoot = lastAccept;
        }
    }

4上面几步效率应该还是挺低的
  public String[] split(CharSequence input, int limit) {
        int index = 0;
        boolean matchLimited = limit > 0;
        ArrayList<String> matchList = new ArrayList<String>();
        Matcher m = matcher(input);

        // Add segments before each match found
        while(m.find()) {
            if (!matchLimited || matchList.size() < limit - 1) {
                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);
    }

1 楼 NARUTOSJP 2012-05-02  

我觉的如果有字符串的话，就把“”这两个省略掉了，故是0开始，如果没有字符串的话，就把“”这两个当成字符串，故是01，所以返回值为1，当然这只是我的猜想。