2团
Published on 2024-09-23 / 15 Visits
0
0

Java基于单字符分割字符串的分割方法性能测试

1. 前言

项目中的TCP连接器需要解码终端设备上传的指令,绝大多数的指令数据字段字段基于","进行分隔,主要使用Java字符串的原生split方法。近期,在优化连接器性能的过程中,对于字符串分割的性能表现产生好奇。

因此基于网上给出的benchmark代码,测试不同编译器下,常见的字符串分割方法的性能表现(注意,基于单字符进行测试)。

2. 测试代码

原始Benchmark代码地址(本文对引用的代码主要进行了格式化调整):

package org.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        System.out.println("Java Version: " + System.getProperty("java.version"));
        System.out.println("Java Vendor: " + System.getProperty("java.vendor") + "\n");

        int n = 10000000;
        long start;

        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            split_banthar(TEST_STR, ',');
        }
        System.out.println("split_banthar: " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            split_tskuzzy(TEST_STR, ',');
        }
        System.out.println("split_tskuzzy: " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            split_tskuzzy2(TEST_STR, ',');
        }
        System.out.println("split_tskuzzy2: " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            split_string_split(TEST_STR, ",");
        }
        System.out.println("string.split: " + (System.currentTimeMillis() - start));


        start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            split_tokenizer(TEST_STR, ",");
        }
        System.out.println("StringTokenizer: " + (System.currentTimeMillis() - start));
    }

    private static final String TEST_STR = "a,b,c,d,e,f,g,h,i,j,asd,asdas,dasdjasodjoa,sjd,oajs,djoasjd,as,odj,jaowdj,oajw,odj,aojwd,oja,owjd,oja,wjdoja,wdj,awjdojaw,odj,oawjd,oja,wjdoawjdojaw,d,dff";

    public static String[] split_tskuzzy(String s, char delimiter) {
        char[] c = s.toCharArray();
        List<String> ll = new ArrayList<>();
        int index = 0;

        for (int i = 0; i < c.length; i++) {
            if (c[i] == delimiter) {
                ll.add(s.substring(index, i));
                index = i + 1;
            }
        }
        return ll.toArray(new String[0]);
    }

    public static String[] split_tskuzzy2(String s, char delimiter) {
        List<String> ll = new ArrayList<>();
        int index = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == delimiter) {
                ll.add(s.substring(index, i));
                index = i + 1;
            }
        }

        if (index != s.length()) {
            ll.add(s.substring(index));
        }
        return ll.toArray(new String[0]);
    }

    public static String[] split_banthar(String s, char delimiter) {

        int count = 1;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == delimiter) {
                count++;
            }
        }

        String[] array = new String[count];
        int a = -1;
        int b = 0;
        for (int i = 0; i < count; i++) {
            while (b < s.length() && s.charAt(b) != delimiter) {
                b++;
            }
            array[i] = s.substring(a + 1, b);
            a = b;
            b++;
        }
        return array;
    }

    private static String[] split_tokenizer(String s, String delimiter) {
        List<String> ll = new ArrayList<>();
        StringTokenizer tokenizer = new StringTokenizer(s, delimiter);
        while (tokenizer.hasMoreElements()) {
            ll.add((String) tokenizer.nextElement());
        }
        return ll.toArray(new String[0]);
    }

    private static String[] split_string_split(String s, String delimiter) {
        return s.split(delimiter);
    }
}

3. 测试结果

3.1 Java 8

Java Version: 1.8.0_422
Java Vendor: Amazon.com Inc.

split_banthar: 4183
split_tskuzzy: 3870
split_tskuzzy2: 4158
string.split: 3847
StringTokenizer: 4923

3.2 Java 11

Java Version: 11.0.24
Java Vendor: Amazon.com Inc.

split_banthar: 4741
split_tskuzzy: 4117
split_tskuzzy2: 5739
string.split: 4237
StringTokenizer: 5132

3.3 Java 17

Java Version: 17.0.12
Java Vendor: Amazon.com Inc.

split_banthar: 4077
split_tskuzzy: 3924
split_tskuzzy2: 5539
string.split: 4057
StringTokenizer: 5519

3.4 Java 21

Java Version: 21.0.3
Java Vendor: Amazon.com Inc.

split_banthar: 4881
split_tskuzzy: 4256
split_tskuzzy2: 5737
string.split: 4394
StringTokenizer: 5627

4. 结论

基于以上的测试结果,可以放心的使用Java中String的原生方法spilt进行单字符分割。

实际上,Java String的spilt方法对单字符(非特殊正则表达式字符)进行了特例优化,满足性能要求,具体参考如下Java源码。

 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.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);
                    int last = length();
                    list.add(substring(off, last));
                    off = last;
                    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, length()));

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


Comment