解析字符串Groovy的最有效方法？

在Groovy中解析以下字符串最有效的方法是什么

 slt-5.16.1.0XYZ

因此，我得到以下结果：

 slt-5.16

值5和16可以是1-nnn

---

非常感谢您的帮助。

在这种情况下，我会建议使用一个简单的

regex

，但由于您要求使用最有效的方法，我尝试了几种方法

TL；DR

使用

substring（）

和两个嵌套的

indexOf（）

：

长篇大论（更新）

我使用Tim Yates的建议更新了基准测试，同时添加了一些有趣的变化。您可以在下面找到结果、一些注意事项以及用于生成它们的代码：

Environment
===========
* Groovy: 2.4.14
* JVM: OpenJDK 64-Bit Server VM (25.71-b00, Oracle Corporation)
    * JRE: 1.8.0-internal
    * Total Memory: 117 MB
    * Maximum Memory: 1710.5 MB
* OS: Linux (4.13.0-37-generic, amd64)

Options
=======
* Warm Up: Auto (- 60 sec)
* CPU Time Measurement: On

                                               user  system    cpu   real

indexOf                                         329       0    329    330
regex, just not a dot                           704       7    711    722
manual loop, int vars                           885       0    885    896
tokenizeJoin                                   1074       0   1074   1079
manual loop, int vars and def i                1078       0   1078   1090
manual loop, Integer vars                      1065       3   1068   1085
manual loop, def vars                          1122       0   1122   1127
regex, restricting to number                   2725      24   2749   2760
manual loop, int vars but index without type  33087       0  33087  33132
manual loop, without types                    47600     286  47886  47944

一些简短的考虑：

• 带有否定组的正则表达式比限制为组的正则表达式快（实际上排名第二）（慢4倍）

• 如果使用静态类型，

  int

  是最快的类型，那么手动循环的速度与我预期的一样快

  Integer

  速度较慢，与

  def

  相当。让它们没有任何类型是最慢的解决方案

守则：

@Grab('org.gperfutils:gbench:0.4.3-groovy-2.4')

def input  = 'slt-5.16.1.0XYZ'
def target = 'slt-5.16'

benchmark {
    'indexOf' {
        assert target == input.substring(0,
                           input.indexOf('.', input.indexOf('.') + 1)
                         )
    }
    'regex, just not a dot' {
        assert input.find(/^[^.]+[.][^.]+/) == target
    }
    'manual loop, int vars' {
        int index, counter = 0 
        for (int i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'tokenizeJoin' {
        assert input.tokenize('.').take(2).join('.') == target
    }
    'manual loop, int vars and def i' {
        int index, counter = 0 
        for (def i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'manual loop, Integer vars' {
        Integer index, counter = 0 
        for (Integer i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'manual loop, def vars' {
        def index, counter = 0
        for (def i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'regex, restricting to numbers' {
        assert (input =~ /(.+-\d+\.\d+)/)[0][1] == target 
    }
    'manual loop, int vars but index without type' {
        int index, counter = 0 
        for (i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'manual loop, without types' {
        counter = 0
        for (i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
}.prettyPrint()

@Grab（'org.gperfutils:gbench:0.4.3-groovy-2.4'）
def输入='slt-5.16.1.0XYZ'
def目标='slt-5.16'
基准{
“indexOf”{
assert target==input.substring（0，
input.indexOf（'.'，input.indexOf（'.'）+1）
)
}
“正则表达式，一点也不”{
断言输入。查找（/^[^.]+[.][^.]+/）==target
}
'手动循环，整数变量'{
整数索引，计数器=0
对于（int i=0；我非常有趣！我认为正则表达式方法是最有效的。我认为我将使用最可读的方法。只是想给我的“朋友”留下深刻印象.嗨，彼得，请接受朱塞佩·里库佩罗的回答，一旦他编辑了我的答案，我将删除他，以显示正确的基准@tim_yates:谢谢你，非常感谢。对我来说，这足以发现
gbench
：）
@Grab('org.gperfutils:gbench:0.4.3-groovy-2.4')

def input  = 'slt-5.16.1.0XYZ'
def target = 'slt-5.16'

benchmark {
    'indexOf' {
        assert target == input.substring(0,
                           input.indexOf('.', input.indexOf('.') + 1)
                         )
    }
    'regex, just not a dot' {
        assert input.find(/^[^.]+[.][^.]+/) == target
    }
    'manual loop, int vars' {
        int index, counter = 0 
        for (int i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'tokenizeJoin' {
        assert input.tokenize('.').take(2).join('.') == target
    }
    'manual loop, int vars and def i' {
        int index, counter = 0 
        for (def i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'manual loop, Integer vars' {
        Integer index, counter = 0 
        for (Integer i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'manual loop, def vars' {
        def index, counter = 0
        for (def i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'regex, restricting to numbers' {
        assert (input =~ /(.+-\d+\.\d+)/)[0][1] == target 
    }
    'manual loop, int vars but index without type' {
        int index, counter = 0 
        for (i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
    'manual loop, without types' {
        counter = 0
        for (i=0; i <input.size(); i++) {
            if (input[i] == '.') { counter++ }
            if (counter == 2) { index = i; break }
        }
        assert input.substring(0,index) == target
    }
}.prettyPrint()