blocks|key|3948084|text|String和Matcher中的replaceFirst/replaceAll操作将始终替换整个匹配项。它们可以归结为如下的实现|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3948085|public+static+String+replace(
++++CharSequence+source,+Pattern+p,+String+replacement,+boolean+all)+{

++++Matcher+m+=+p.matcher(source);
++++if(!m.find())+return+source.toString();
++++StringBuffer+sb+=+new+StringBuffer();
++++do+m.appendReplacement(sb,+replacement);+while(all+&&+m.find());
++++return+m.appendTail(sb).toString();
}|code-block|syntax|javascript|3948086|注意，在Java9之前，我们必须在这里使用StringBuffer而不是StringBuilder。|3948087|当我们忽略在替换字符串中具有组引用的功能时，我们可以向下钻取更深一层的逻辑，并获得|3948088|public+static+String+replaceLiteral(
++++CharSequence+source,+Pattern+p,+String+replacement,+boolean+all)+{

++++Matcher+m+=+p.matcher(source);
++++if(!m.find())+return+source.toString();
++++StringBuilder+sb+=+new+StringBuilder();
++++int+lastEnd+=+0;
++++do+{
++++++++sb.append(source,+lastEnd,+m.start()).append(replacement);
++++++++lastEnd+=+m.end();
++++}+while(all+&&+m.find());
++++return+sb.append(source,+lastEnd,+source.length()).toString();
}|3948089|对于这段代码，很容易更改逻辑来替换特定的命名组，而不是整个匹配：|3948090|public+static+String+replaceGroupWithLiteral(
++++CharSequence+source,+Pattern+p,+String+groupName,+String+replacement,+boolean+all)+{

++++Matcher+m+=+p.matcher(source);
++++if(!m.find())+return+source.toString();
++++StringBuilder+sb+=+new+StringBuilder();
++++int+lastEnd+=+0;
++++do+{
++++++++sb.append(source,+lastEnd,+m.start(groupName)).append(replacement);
++++++++lastEnd+=+m.end(groupName);
++++}+while(all+&&+m.find());
++++return+sb.append(source,+lastEnd,+source.length()).toString();
}|3948091|这已经足够实现您的示例了：|3948092|private+static+final+String+NAME_GROUP+=+"name";
public+static+final+Pattern+pattern
++++=+Pattern.compile("<.*:name>"+%2B+"(?<"+%2B+NAME_GROUP+%2B+">.*)</.*:name>");|3948093|String+input+=
++++"<xml\n"
++%2B+"+++<user:address>.../</user:address>\n"
++%2B+"+++<user:name>foo</user:name>\n"
++%2B+"</xml>\n";
String+s+=+replaceGroupWithLiteral(input,+pattern,+NAME_GROUP,+"hello",+false);
System.out.println(s);|3948094|<xml
+++<user:address>.../</user:address>
+++<user:name>hello</user:name>
</xml>|3948095|不过，我可能会用像这样的东西|3948096|public+static+final+Pattern+pattern
++++=+Pattern.compile("<([%5E<>:]*?:name)>"+%2B+"(?<"+%2B+NAME_GROUP+%2B+">.*)</\\1>");|3948097|如上所述(通过方法名称可以清楚地看出)，这与普通的regex替换操作不同，因为它总是按字面意思插入替换。要获得与原型相同的行为，需要更复杂和效率更低的代码，所以我只在确实需要引用组时才使用它(或者语法被认为是合同中的替代语法)。|3948098|public+static+String+replaceGroup(
++++CharSequence+source,+Pattern+p,+String+groupName,+String+replacement,+boolean+all)+{

++++Matcher+m+=+p.matcher(source);
++++if(!m.find())+return+source.toString();
++++StringBuffer+sb+=+new+StringBuffer();
++++do+{
++++++++int+s+=+m.start(),+gs+=+m.start(groupName),+e+=+m.end(),+ge+=+m.end(groupName);
++++++++String+prefix+=+s+==+gs?+"":
++++++++++++Matcher.quoteReplacement(source.subSequence(s,+gs).toString());
++++++++String+suffix+=+e+==+ge?+"":
++++++++++++Matcher.quoteReplacement(source.subSequence(ge,+e).toString());
++++++++m.appendReplacement(sb,+prefix%2Breplacement%2Bsuffix);
++++}+while(all+&&+m.find());
++++return+m.appendTail(sb).toString();
}|3948099|有了这个，如果我们使用，例如|3948100|String+s+=+replaceGroup(input,+pattern,+NAME_GROUP,+"[[${"%2BNAME_GROUP%2B"}]]",+false);|3948101|我们会得到|3948102|<xml
+++<user:address>.../</user:address>
+++<user:name>[[foo]]</user:name>
</xml>|3948103|entityMap^0|0|6|7|7|G|C|T|A|0|0|L|C|10|D|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|20|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|21|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|22|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|23|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|24|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|H|7|25|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|H|7|26|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|27|8|@]|D|@]|E|$]]|$1|14|3|15|5|H|7|28|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|29|8|@]|D|@]|E|$]]|$1|18|3|19|5|H|7|2A|8|@]|D|@]|E|$I|J]]|$1|1A|3|1B|5|6|7|2B|8|@]|D|@]|E|$]]|$1|1C|3|1D|5|H|7|2C|8|@]|D|@]|E|$I|J]]|$1|1E|3|1F|5|6|7|2D|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|H|7|2E|8|@]|D|@]|E|$I|J]]|$1|1I|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]]|1J|$]]

The operations <code>replaceFirst</code>/<code>replaceAll</code> in <code>String</code> and <code>Matcher</code> will always replace an entire match. They boil down to an implementation like

<pre><code>public static String replace(
 CharSequence source, Pattern p, String replacement, boolean all) {

 Matcher m = p.matcher(source);
 if(!m.find()) return source.toString();
 StringBuffer sb = new StringBuffer();
 do m.appendReplacement(sb, replacement); while(all &amp;&amp; m.find());
 return m.appendTail(sb).toString();
}
</code></pre>

Note that prior to Java 9, we have to use <code>StringBuffer</code> instead of <code>StringBuilder</code> here.

When we ignore the capability to have group references in the replacement string, we can drill down one level deeper into the logic and get

<pre><code>public static String replaceLiteral(
 CharSequence source, Pattern p, String replacement, boolean all) {

 Matcher m = p.matcher(source);
 if(!m.find()) return source.toString();
 StringBuilder sb = new StringBuilder();
 int lastEnd = 0;
 do {
 sb.append(source, lastEnd, m.start()).append(replacement);
 lastEnd = m.end();
 } while(all &amp;&amp; m.find());
 return sb.append(source, lastEnd, source.length()).toString();
}
</code></pre>

For this code, it’s quiet easy to change the logic to replace a particular named group rather than the entire match:

<pre><code>public static String replaceGroupWithLiteral(
 CharSequence source, Pattern p, String groupName, String replacement, boolean all) {

 Matcher m = p.matcher(source);
 if(!m.find()) return source.toString();
 StringBuilder sb = new StringBuilder();
 int lastEnd = 0;
 do {
 sb.append(source, lastEnd, m.start(groupName)).append(replacement);
 lastEnd = m.end(groupName);
 } while(all &amp;&amp; m.find());
 return sb.append(source, lastEnd, source.length()).toString();
}
</code></pre>

This is already sufficient to implement your example:

<pre><code>private static final String NAME_GROUP = "name";
public static final Pattern pattern
 = Pattern.compile("&lt;.*:name&gt;" + "(?&lt;" + NAME_GROUP + "&gt;.*)&lt;/.*:name&gt;");
</code></pre>



<pre><code>String input =
 "&lt;xml\n"
 + " &lt;user:address&gt;.../&lt;/user:address&gt;\n"
 + " &lt;user:name&gt;foo&lt;/user:name&gt;\n"
 + "&lt;/xml&gt;\n";
String s = replaceGroupWithLiteral(input, pattern, NAME_GROUP, "hello", false);
System.out.println(s);
</code></pre>

<pre class="lang-none prettyprint-override"><code>&lt;xml
 &lt;user:address&gt;.../&lt;/user:address&gt;
 &lt;user:name&gt;hello&lt;/user:name&gt;
&lt;/xml&gt;
</code></pre>

Though I’d probably use something like

<pre><code>public static final Pattern pattern
 = Pattern.compile("&lt;([^&lt;&gt;:]*?:name)&gt;" + "(?&lt;" + NAME_GROUP + "&gt;.*)&lt;/\\1&gt;");
</code></pre>

As said (and made clear by the method name), this differs from the ordinary regex replace operation, as it will always insert the replacement literally. Getting the same behavior as the archetype, requires more complex and less efficient code, so I’d use it only when referencing groups really is required (or the syntax is supposed to be the replacement syntax by contract).

<pre><code>public static String replaceGroup(
 CharSequence source, Pattern p, String groupName, String replacement, boolean all) {

 Matcher m = p.matcher(source);
 if(!m.find()) return source.toString();
 StringBuffer sb = new StringBuffer();
 do {
 int s = m.start(), gs = m.start(groupName), e = m.end(), ge = m.end(groupName);
 String prefix = s == gs? "":
 Matcher.quoteReplacement(source.subSequence(s, gs).toString());
 String suffix = e == ge? "":
 Matcher.quoteReplacement(source.subSequence(ge, e).toString());
 m.appendReplacement(sb, prefix+replacement+suffix);
 } while(all &amp;&amp; m.find());
 return m.appendTail(sb).toString();
}
</code></pre>

With this, if we use, e.g.

<pre><code>String s = replaceGroup(input, pattern, NAME_GROUP, "[[${"+NAME_GROUP+"}]]", false);
</code></pre>

we get

<pre class="lang-none prettyprint-override"><code>&lt;xml
 &lt;user:address&gt;.../&lt;/user:address&gt;
 &lt;user:name&gt;[[foo]]&lt;/user:name&gt;
&lt;/xml&gt;
</code></pre>

I want to replace the value of "name" node in both examples. I use regex group to match for it and replace. The grouping is working but replacing does not.

<pre><code>input 1
&lt;xml
 &lt;user:address&gt;.../&lt;/user:address&gt;
 &lt;user:name&gt;foo&lt;/user:name&gt;
&lt;/xml&gt;

input 2

&lt;xml
 &lt;user:address&gt;.../&lt;/user:address&gt;
 &lt;street:name&gt;bar&lt;/street:name&gt;
&lt;/xml&gt;


private static final String NAME_GROUP = "name";
public static final Pattern pattern = Pattern.compile("&lt;.*:name&gt;" + "(?&lt;" + NAME + "&gt;.*)&lt;/.*:name&gt;");

final Matcher nameMatcher = pattern.matcher(str);
final String s = nameMatcher.find() ? nameMatcher.group(NAME_GROUP) : null;
System.out.println(s);

//foo
//bar
</code></pre>

now when I do replace

<pre><code>String output = nameMatcher.replaceFirst("hello")
 I get 
 hello&lt;/xml&gt;
</code></pre>

while I expected the following

<pre><code>&lt;xml
 &lt;user:address&gt;.../&lt;/user:address&gt;
 &lt;user:name&gt;hello&lt;/user:name&gt;
 &lt;/xml&gt;
</code></pre>

For both examples. Why group is working but not replacement?

RegEx for capturing and replacing an element textContent

我想要替换这两个示例中"name“节点的值。我使用regex group来匹配并替换它。分组工作正常，但替换不起作用。input 1<xml <user:address>.../</user:address> <user:name>foo</user:name></xml>input 2<xml <user...

问用于捕获和替换元素textContent的RegEx
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用于捕获和替换元素textContent的RegExEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用于捕获和替换元素textContent的RegEx
EN