Java 嵌套regexp和replace

我有这样的字符串

，我想用

vX

交换

pX

，用regexps交换

。 我只想交换

中的对

我写道：

Pattern pattern = Pattern.compile("<(\\w*)=(\\w*)>");
Matcher matcher = pattern.matcher("<p1=v1>");
System.out.println(matcher.replaceAll("$2=$1"));

Pattern=Pattern.compile（“”）；
Matcher Matcher=pattern.Matcher（“”）；
System.out.println（matcher.replaceAll（$2=$1））；

但它仅适用于一对

pX=vX

有人能告诉我如何编写适用于多对的regexp吗？

简单，使用组：

String input = "<p0=v0 p1=v1 p2=v2>";
//                                   |group 1
//                                   ||matches "p" followed by one digit
//                                   ||      |... followed by "="
//                                   ||      ||group 2
//                                   ||      |||... followed by "v", followed by one digit
//                                   ||      |||          |replaces group 2 with group 1,
//                                   ||      |||          |re-writes "=" in the middle
System.out.println(input.replaceAll("(p[0-9])=(v[0-9])", "$2=$1"));

字符串输入=”；
//|第1组
//| |匹配“p”，后跟一位数字
//                                   ||      |... 后跟“=”
//| | | |第2组
//                                   ||      |||... 后跟“v”，后跟一位数字
//| | | | | |将组2替换为组1，
在中间写“=”
System.out.println（input.replaceAll（“（p[0-9]）=（v[0-9]）”，“$2=$1”）；

输出：

<v0=p0 v1=p1 v2=p2>

替换
之间的所有内容（我们称之为标签）是-imho-如果标签外部可能出现相同的模式，则不可能

为了同时替换所有内容，我选择了两个正则表达式：

String str = "<p1=v1 p2=v2> p3=v3 <p4=v4>";
Pattern insideTag = Pattern.compile("<(.+?)>");
Matcher m = insideTag.matcher(str);

while(m.find()) {
    str = str.replace(m.group(1), m.group(1).replaceAll("(\\w*)=(\\w*)", "$2=$1"));
}
System.out.println(str);

//prints: <v1=p1 v2=p2> p3=v3 <v4=p4>

给出输出

<v1=p1 v2=p2 just some trash> p3=v3 <v4=p4>

p3=v3
如果Java可以做
\G
锚定，这将适用于未列出的

查找：
（（？：（？！\A |））前面必须有一个结束>

Perl测试用例

$/ = undef;
$str = <DATA>;
$str =~ s/((?:(?!\A|<)\G|<)[^<>]*?)(\w+)=(\w+)(?=[^<>]*?>)/$1$3=$2/g;
print $str;
__DATA__
<p0=v0 p1=v1  p2=v2 ....>

$/=undf；
$str=；
$str=~s/（？：（！\A |>

这应该可以只在
<和>
之间交换那些对：

String string = "<p0=v0 p1=v1 p2=v2> a=b c=d xyz=abc <foo=bar baz=bat>";
Pattern pattern1 = Pattern.compile("<[^>]+>");
Pattern pattern2 = Pattern.compile("(\\w+)=(\\w+)");
Matcher matcher1 = pattern1.matcher(string);
StringBuffer sbuf = new StringBuffer();
while (matcher1.find()) {
    Matcher matcher2 = pattern2.matcher(matcher1.group());
    matcher1.appendReplacement(sbuf, matcher2.replaceAll("$2=$1"));
}
matcher1.appendTail(sbuf);
System.out.println(sbuf);

String String=“a=b c=d xyz=abc”；
Pattern pattern1=Pattern.compile（“]+>”）；
Pattern pattern2=Pattern.compile（“（\\w+）=（\\w+）”；
Matcher matcher1=pattern1.Matcher（字符串）；
StringBuffer sbuf=新的StringBuffer（）；
while（matcher1.find（））{
Matcher matcher2=pattern2.Matcher（matcher1.group（））；
matcher1.appendReplacement（sbuf，matcher2.replaceAll（“$2=$1”）；
}
匹配器1.附录尾（sbuf）；
系统输出打印LN（sbuf）；

输出：
a=b c=d xyz=abc
您可以使用以下模式：

"((?:<|\\G(?<!\\A))\\s*)(p[0-9]+)(\\s*=\\s*)(v[0-9]+)"

如果您需要p和v具有相同的编号，可以将其更改为：

String pattern = "((?:<|\\G(?<!\\A))\\s*)(p([0-9]+))(\\s*=\\s*)(v\\3)";
String result = subject.replaceAll(pattern, "$1$5$4$2");

String pattern=“（（？：]+\\s*）*？\\s*）（p（[0-9]+）（\\s*=\\s*）（v\\3）”；
字符串结果=subject.replaceAll（模式，“$1$4$3$2”）；

注意：所有这些图案仅检查是否有开口角括号，但不检查是否有闭合角括号。如果缺少闭合角括号，则将替换所有对，直到前两个图案不再有相邻的对，直到下一个闭合角括号或字符串结束r第三种模式

您可以通过在每个图案的末尾添加
（？=[^]*>）
来检查是否存在闭合角括号。但是，添加此选项将使图案完全不起作用。最好使用
（？也许可以从模式中去掉
？我希望它只在
之间交换那些对。您的示例输入字符串只包含
内部的数据。它外部是否有
x=y
对，如
p4=v4
，这是您想要避免的？但是您的解决方案交换了所有对，而我想让它只在
之间交换那些对吗？你认为他需要使用有序的“p”和“v”以及数字常量，或者
\w
像在他的正则表达式中那样的可变性吗？对不起，现在从我的平板电脑上看-明天会仔细查看并调整。看起来问题现在已经得到了回答…对不起，我无法完成s、 工作正常，但没有解释。我找到了一个教程，它对理解您的解决方案很有用。@user3329098:很抱歉，我有连接问题，我将添加解释。
String string = "<p0=v0 p1=v1 p2=v2> a=b c=d xyz=abc <foo=bar baz=bat>";
Pattern pattern1 = Pattern.compile("<[^>]+>");
Pattern pattern2 = Pattern.compile("(\\w+)=(\\w+)");
Matcher matcher1 = pattern1.matcher(string);
StringBuffer sbuf = new StringBuffer();
while (matcher1.find()) {
    Matcher matcher2 = pattern2.matcher(matcher1.group());
    matcher1.appendReplacement(sbuf, matcher2.replaceAll("$2=$1"));
}
matcher1.appendTail(sbuf);
System.out.println(sbuf);

<v0=p0 v1=p1 v2=p2> a=b c=d xyz=abc <bar=foo bat=baz>

"((?:<|\\G(?<!\\A))\\s*)(p[0-9]+)(\\s*=\\s*)(v[0-9]+)"

(?:<|\\G(?<!\\A))

String subject = "p5=v5 <p0=v0 p1=v1 p2=v2 p3=v3> p4=v4";
String pattern = "((?:<|\\G(?<!\\A))\\s*)(p[0-9]+)(\\s*=\\s*)(v[0-9]+)";
String result = subject.replaceAll(pattern, "$1$4$3$2");

String pattern = "((?:<|\\G(?<!\\A))\\s*)(p([0-9]+))(\\s*=\\s*)(v\\3)";
String result = subject.replaceAll(pattern, "$1$5$4$2");

String pattern = "((?:<|\\G(?<!\\A))(?:[^\s>]+\\s*)*?\\s*)(p([0-9]+))(\\s*=\\s*)(v\\3)";
String result = subject.replaceAll(pattern, "$1$4$3$2");