Java 如何将字符串一分为二考虑字符串末尾的数字（在方括号内）

我需要使用正则表达式使用给定的分隔符将字符串拆分为两个。 示例字符串和预期输出如下所示

testnames[3] ===> testnames,3
3alpha[0] ====> 3alpha, 0
beta[4]value[2] ===> beta[4]value, 2
gama4[23] ===> gama4, 23
tama[2334] ====> tama, 2334
tes[t[ ===> No matches
try[]t ===> No matches

如果每个字符串在输入字符串的端的方括号内有数字，则应将其拆分为两个

谁能告诉我一个正则表达式来做这个

注意： 我找到了正则表达式：

“\[（-d+）\]$”

。

---

但这只给出了方括号内的数字，没有给出字符串的其余部分

您可以使用正则表达式替换：

$1, $2

String input=“beta[4]值[2]”；
字符串输出=输入.replaceAll（“\\[（\\d+\\]）（？！.\\[\\d+\\]）”，“，$1”）；
系统输出打印项次（输入）；
系统输出打印项次（输出）；

这张照片是：

beta[4]value[2]
beta[4]value, 2

这里使用的正则表达式模式是

\[（\d+）\]（？！.\[\d+\]）

，表示：

\[(\d+)\]      match a number in square brackets AND capture that number in $1
(?!.*\[\d+\])  then assert that we do NOT find another [num] term
               this ensures that we only replace the last [num] term

---

然后我们用逗号替换，后跟空格和捕获的数字。

流

版本：

import java.util.List;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of(
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
                ).forEach(s -> System.out.println(s + " => " + getTokens(s)));  
    }
    static List<String> getTokens(String str){
        return Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])")
                        .matcher(str)
                        .results()
                        .map(MatchResult::group)
                        .collect(Collectors.toList());
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String [] arr = {
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
        };
        
        for(String s: arr) {
            System.out.println(s + " => " + getTokens(s));
        }
    }
    static List<String> getTokens(String str){
        Pattern pattern = Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])");
        Matcher matcher = pattern.matcher(str);
        List<String> list = new ArrayList<>();
        while(matcher.find()) {
            list.add(matcher.group());
        }
        return list;
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

String repl = str.replaceFirst("^(.*)\\[(\\d+)\\]", "$1, $2");

正则表达式的解释如下：

import java.util.List;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of(
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
                ).forEach(s -> System.out.println(s + " => " + getTokens(s)));  
    }
    static List<String> getTokens(String str){
        return Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])")
                        .matcher(str)
                        .results()
                        .map(MatchResult::group)
                        .collect(Collectors.toList());
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String [] arr = {
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
        };
        
        for(String s: arr) {
            System.out.println(s + " => " + getTokens(s));
        }
    }
    static List<String> getTokens(String str){
        Pattern pattern = Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])");
        Matcher matcher = pattern.matcher(str);
        List<String> list = new ArrayList<>();
        while(matcher.find()) {
            list.add(matcher.group());
        }
        return list;
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

String repl = str.replaceFirst("^(.*)\\[(\\d+)\\]", "$1, $2");

非

流

版本：

import java.util.List;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of(
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
                ).forEach(s -> System.out.println(s + " => " + getTokens(s)));  
    }
    static List<String> getTokens(String str){
        return Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])")
                        .matcher(str)
                        .results()
                        .map(MatchResult::group)
                        .collect(Collectors.toList());
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String [] arr = {
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
        };
        
        for(String s: arr) {
            System.out.println(s + " => " + getTokens(s));
        }
    }
    static List<String> getTokens(String str){
        Pattern pattern = Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])");
        Matcher matcher = pattern.matcher(str);
        List<String> list = new ArrayList<>();
        while(matcher.find()) {
            list.add(matcher.group());
        }
        return list;
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

String repl = str.replaceFirst("^(.*)\\[(\\d+)\\]", "$1, $2");

---

您可以将此贪婪匹配替换用于2个捕获组：

正则表达式：

^(.*)\[(\d+)\]

替换：

$1, $2

Java代码：

import java.util.List;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of(
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
                ).forEach(s -> System.out.println(s + " => " + getTokens(s)));  
    }
    static List<String> getTokens(String str){
        return Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])")
                        .matcher(str)
                        .results()
                        .map(MatchResult::group)
                        .collect(Collectors.toList());
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String [] arr = {
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
        };
        
        for(String s: arr) {
            System.out.println(s + " => " + getTokens(s));
        }
    }
    static List<String> getTokens(String str){
        Pattern pattern = Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])");
        Matcher matcher = pattern.matcher(str);
        List<String> list = new ArrayList<>();
        while(matcher.find()) {
            list.add(matcher.group());
        }
        return list;
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

String repl = str.replaceFirst("^(.*)\\[(\\d+)\\]", "$1, $2");

正则表达式解释：

import java.util.List;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.of(
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
                ).forEach(s -> System.out.println(s + " => " + getTokens(s)));  
    }
    static List<String> getTokens(String str){
        return Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])")
                        .matcher(str)
                        .results()
                        .map(MatchResult::group)
                        .collect(Collectors.toList());
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String [] arr = {
                    "testnames[3]",
                    "3alpha[0]",
                    "beta[4]value[2]",
                    "gama4[23]",
                    "tama[2334]",
                    "tes[t[",
                    "try[]t"
        };
        
        for(String s: arr) {
            System.out.println(s + " => " + getTokens(s));
        }
    }
    static List<String> getTokens(String str){
        Pattern pattern = Pattern.compile("(\\w+(?:\\[\\d+\\]\\w+)?)(?=\\[\\d+\\])|(?<=\\[)\\d+(?=\\])");
        Matcher matcher = pattern.matcher(str);
        List<String> list = new ArrayList<>();
        while(matcher.find()) {
            list.add(matcher.group());
        }
        return list;
    }
}

testnames[3] => [testnames, 3]
3alpha[0] => [3alpha, 0]
beta[4]value[2] => [beta[4]value, 2]
gama4[23] => [gama4, 23]
tama[2334] => [tama, 2334]
tes[t[ => []
try[]t => []

String repl = str.replaceFirst("^(.*)\\[(\\d+)\\]", "$1, $2");

• ^

  ：开始

• （.*）

  ：贪婪地匹配捕获组#1中的0个或多个字符

• \[

  ：匹配一个

  [

• （\d+）

  ：匹配捕获组2中的一个或多个数字

• \]

  ：匹配一个

  ]

使用