目录

• 工作中常用的 split () 切割 字符串 效率高吗？
• JDK 提供字符串切割工具类 String Tokenizer
• 手把手带你实现一个更高效的字符串切割工具类
• 总结

今天给大家介绍一个小知识点，但是会非常的实用，就是平时我们写 java 代码的时候，如果要对字符串进行切割，我们巧妙的运用一些技巧，可以把性能提升 5~10 倍。下面不说废话，直接来给大家上干货！

工作中常用的 split() 切割字符串效率高吗？

首先，我们用下面的一段代码，去拼接出来一个用逗号分隔的超长字符串，把从 0 开始一直到 9999 的每个数字都用逗号分隔，拼接成一个超长的字符串，以便于我们可以进行实验。

代码如下所示：

 public class  string SplitTest {

    public  static   void  main(String[] args) {
        String string = null;
         StringBuffer   stringBuffer  = new StringBuffer();

        int max = 10000;
        for(int i = 0; i < max; i++) {
            stringBuffer.append(i);
            if(i < max - 1) {
                stringBuffer.append(",");
            }
        }
        string = stringBuffer.toString();
    }

}  

接着我们可以用下面的代码来测试一下，如果用最基础的 split 方法来对超长字符串做切割，循环切割 1w 次，要耗费多长时间，看如下代码测试：

 public class StringSplitTest {

    public static void main(String[] args) {
        String string = null;
        StringBuffer stringBuffer = new StringBuffer();

        int max = 10000;
        for(int i = 0; i < max; i++) {
            stringBuffer.append(i);
            if(i < max - 1) {
                stringBuffer.append(",");
            }
        }
        string = stringBuffer.toString();

        long start = System.currentTimeMillis();
        for(int i = 0; i < 10000; i++) {
            string.split(",");
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

}  

经过上面代码的测试，最终发现用 split 方法对字符串按照逗号进行切割，切割 1w 次是耗时 2000 多毫秒，这个不太固定，大概是 2300 毫秒左右。

JDK 提供字符串切割工具类 StringTokenizer

接着给大家介绍另外一个性能更加好的专门用于字符串切割的工具类，就是 StringTokenizer ，这个工具是 JDK 提供的，也是专门用来进行字符串切割的，他的性能会更好一些。

我们可以看下面的代码，用他来进行 1w 次字符串切割，看看具体的性能测试结果如何：

 import java.util. stringTokenizer ;

public class StringSplitTest {

    public static void main(String[] args) {
        String string = null;
        StringBuffer stringBuffer = new StringBuffer();

        int max = 10000;
        for(int i = 0; i < max; i++) {
            stringBuffer.append(i);
            if(i < max - 1) {
                stringBuffer.append(",");
            }
        }
        string = stringBuffer.toString();

        long start = System.currentTimeMillis();
        for(int i = 0; i < 10000; i++) {
            string.split(",");
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

        start = System.currentTimeMillis();
        StringTokenizer stringTokenizer =
                new StringTokenizer(string, ",");
        for(int i = 0; i < 10000; i++) {
            while(stringTokenizer.hasMoreTokens()) {
                stringTokenizer.nextToken();
            }
            stringTokenizer = new StringTokenizer(string, ",");
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }

}  

大家看上面的代码，用 StringTokenizer 可以通过 hasMoreTokens() 方法判断是否有切割出的下一个元素，如果有就用 nextToken() 拿到这个切割出来的元素，一次全部切割完毕后，就重新创建一个新的 StringTokenizer 对象。

这样连续切割 1w 次，经过测试之后，会发现用 StringTokenizer 切割字符串 1w 次的耗时大概是 1900 毫秒左右。

大家感觉如何？是不是看到差距了？换一下切割字符串的方式，就可以让耗时减少 400~500ms，性能目前已经可以提升 20% 了。

手把手带你实现一个更高效的字符串切割工具类

接着我们来自己封装一个切割字符串的函数，用这个函数再来做一次字符串切割看看。

大家先看字符串切割函数的代码：

  private  static void split(String string) {
  String remainString = string;
  int startIndex = 0;
  int endIndex = 0;
  while(true) {
    endIndex = remainString.indexOf(",", startIndex);
    if(endIndex <= 0) {
      break;
    }
    remainString.substring(startIndex, endIndex);
    startIndex = endIndex + 1;
  }
}  

上面那段代码是我们自定义的字符串切割函数，大概意思是说，每一次切割都走一个 while 循环，startIndex 初始值是 0，然后每一次循环都找到从 startIndex 开始的下一个逗号的 index，就是 endIndex，基于 startIndex 和 endIndex 截取一个字符串出来。

然后 startIndex 可以推进到本次 endIndex + 1 即可，下一次循环就会截取下一个逗号之前的子字符串了。

下面我们用用上述自定义的切割函数再次测试一下，如下代码：

 import java.util.StringTokenizer;

public class StringSplitTest {

    public static void main(String[] args) {
        String string = null;
        StringBuffer stringBuffer = new StringBuffer();

        int max = 10000;
        for(int i = 0; i < max; i++) {
            stringBuffer.append(i);
            if(i < max - 1) {
                stringBuffer.append(",");
            }
        }
        string = stringBuffer.toString();

        long start = System.currentTimeMillis();
        for(int i = 0; i < 10000; i++) {
            string.split(",");
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

        start = System.currentTimeMillis();
        StringTokenizer stringTokenizer =
                new StringTokenizer(string, ",");
        for(int i = 0; i < 10000; i++) {
            while(stringTokenizer.hasMoreTokens()) {
                stringTokenizer.nextToken();
            }
            stringTokenizer = new StringTokenizer(string, ",");
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);

        start = System.currentTimeMillis();
        for(int i = 0; i < 10000; i++) {
            split(string);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    private static void split(String string) {
        String remainString = string;
        int startIndex = 0;
        int endIndex = 0;
        while(true) {
            endIndex = remainString.indexOf(",", startIndex);
            if(endIndex <= 0) {
                break;
            }
            remainString.substring(startIndex, endIndex);
            startIndex = endIndex + 1;
        }
    }

}  

总结

经过上述代码测试之后，我们自己写的字符串切割函数的耗时大概是在 1000ms 左右，相比较之下，比 String.split 方法的性能提升了 2 倍多，比 StringTokenizer 的性能也提升了 2 倍，如果要是字符串更大呢？

其实字符串越大，性能差距就会越多，可能会呈更大的倍数提升我们的性能！

————- END ————-

另外推荐儒猿课堂的1元系列课程给您，欢迎加入一起学习~