blocks|key|398967|text|这可能比您最初认为的要复杂一些，因为您不仅需要匹配字符，而且缺少特定的短语-一个被否定的字符集是不够的。如果字符串是123，则需要：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|398968|(?<=%5E%7C123)(?!123).*?(?=123%7C$)|code-block|syntax|javascript|398969|https://regex101.com/r/EZWMqM/1/|offset|length|398970|也就是说，对于字符串的开头或"123"，请确保当前位置后面没有123，然后延迟重复任何字符，直到lookahead匹配"123“或字符串的结尾。这将匹配不在"123“子字符串中的所有字符。然后，您需要将每个字符替换为%2B，然后您可以使用appendReplacement和StringBuffer创建结果字符串：|style|CODE|398971|String+inputPhrase+=+"123";
String+inputStr+=+"abc123efg123123hij";
StringBuffer+resultString+=+new+StringBuffer();
Pattern+regex+=+Pattern.compile("(?<=%5E%7C"+%2B+inputPhrase+%2B+")(?!"+%2B+inputPhrase+%2B+").*?(?="+%2B+inputPhrase+%2B+"%7C$)");
Matcher+m+=+regex.matcher(inputStr);
while+(m.find())+{
++++String+replacement+=+m.group(0).replaceAll(".",+"%2B");
++++m.appendReplacement(resultString,+replacement);
}
m.appendTail(resultString);
System.out.println(resultString.toString());|398972|输出：|398973|%2B%2B%2B123%2B%2B%2B123123%2B%2B%2B|398974|请注意，如果inputPhrase可以在正则表达式中包含具有特殊含义的字符，则在连接到模式之前必须首先对它们进行转义。|398975|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|W|0|0|30|1|39|H|3R|C|0|0|0|0|6|B|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@]|9|@$I|16|J|17|1|18]]|A|$]]|$1|K|3|L|5|6|7|19|8|@$I|1A|J|1B|M|N]|$I|1C|J|1D|M|N]|$I|1E|J|1F|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1H|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1J|8|@$I|1K|J|1L|M|N]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|H]]]]

This is a bit trickier than you might initially think because you don't just need to match characters, but the absence of specific phrase - a negated character set is not enough. If the string is 123, you would need:

<pre><code>(?&lt;=^|123)(?!123).*?(?=123|$)
</code></pre>

<a href="https://regex101.com/r/EZWMqM/1/" rel="nofollow noreferrer">https://regex101.com/r/EZWMqM/1/</a>

That is - lookbehind for the start of the string or "123", make sure the current position is not followed by 123, then lazy-repeat any character until lookahead matches "123" or the end of the string. This will match all characters which are not in a "123" substring. Then, you need to replace each character with a <code>+</code>, after which you can use <code>appendReplacement</code> and a <code>StringBuffer</code> to create the result string:

<pre><code>String inputPhrase = "123";
String inputStr = "abc123efg123123hij";
StringBuffer resultString = new StringBuffer();
Pattern regex = Pattern.compile("(?&lt;=^|" + inputPhrase + ")(?!" + inputPhrase + ").*?(?=" + inputPhrase + "|$)");
Matcher m = regex.matcher(inputStr);
while (m.find()) {
 String replacement = m.group(0).replaceAll(".", "+");
 m.appendReplacement(resultString, replacement);
}
m.appendTail(resultString);
System.out.println(resultString.toString());
</code></pre>

Output:

<pre><code>+++123+++123123+++
</code></pre>

Note that if the <code>inputPhrase</code> can contain character with a special meaning in a regular expression, you'll have to escape them first before concatenating into the pattern.

blocks|key|401832|text|因此，不是想出一个正则表达式来匹配缺少字符串的情况。我们可能只需要匹配所选的短语，并将跳过的字符数附加到%2B。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|401833|StringBuilder+sb+=+new+StringBuilder();
Matcher+m+=+Pattern.compile(Pattern.quote(str)).matcher(input);
while+(m.find())+{
++++for+(int+i+=+0;+i+<+m.start();+i%2B%2B)+sb.append('%2B');
++++sb.append(str);
}
int+remaining+=+input.length()+-+sb.length();
for+(int+i+=+0;+i+<+remaining;+i%2B%2B)+{
++++sb.append('%2B');
}|code-block|syntax|javascript|401834|entityMap^0|1G|1|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

So instead of coming up with a regular expression that matches the absence of a string. We might as well just match the selected phrase and append <code>+</code> the number of skipped characters.

<pre><code>StringBuilder sb = new StringBuilder();
Matcher m = Pattern.compile(Pattern.quote(str)).matcher(input);
while (m.find()) {
 for (int i = 0; i &lt; m.start(); i++) sb.append('+');
 sb.append(str);
}
int remaining = input.length() - sb.length();
for (int i = 0; i &lt; remaining; i++) {
 sb.append('+');
}
</code></pre>

blocks|key|396094|text|你可以用一行代码来完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|396095|input+=+input.replaceAll("((?:"+%2B+str+%2B+")%2B)?(?!"+%2B+str+%2B+").((?:"+%2B+str+%2B+")%2B)?",+"$1%2B$2");|code-block|syntax|javascript|396096|这将选择性地捕获每个字符的两侧的"123“，并将它们放回原处(如果没有”123“，则为空)：|396097|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can do it in one line:

<pre><code>input = input.replaceAll("((?:" + str + ")+)?(?!" + str + ").((?:" + str + ")+)?", "$1+$2");
</code></pre>

This optionally captures "123" either side of each character and puts them back (a blank if there's no "123"):

blocks|key|3438260|text|看起来这就是CodingBat上的plusOut问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3438261|对于这个问题，我有3个解决方案，我写了一个新的流媒体解决方案，只是为了好玩。|3438262|解决方案1:循环和检查|3438263|根据输入字符串创建一个StringBuilder，并检查每个位置的单词。如果不匹配，则替换该字符，如果找到，则跳过该单词的长度。|3438264|public+String+plusOut(String+str,+String+word)+{
++StringBuilder+out+=+new+StringBuilder(str);

++for+(int+i+=+0;+i+<+out.length();+)+{
++++if+(!str.startsWith(word,+i))
++++++out.setCharAt(i%2B%2B,+'%2B');
++++else
++++++i+%2B=+word.length();
++}

++return+out.toString();
}|code-block|syntax|javascript|3438265|这可能是初学者的预期答案，尽管有一个假设字符串不包含任何星形平面字符，这将由2个字符而不是1来表示。|3438266|解决方案2:用标记替换单词，替换其余单词，然后恢复单词|3438267|public+String+plusOut(String+str,+String+word)+{
++++return+str.replaceAll(java.util.regex.Pattern.quote(word),+"@").replaceAll("[%5E@]",+"%2B").replaceAll("@",+word);
}|3438268|这不是一个正确的解决方案，因为它假设某个字符或字符序列不出现在字符串中。|3438269|注意，使用Pattern.quote来防止replaceAll方法将word解释为正则表达式语法。|3438270|解决方案3:使用\G的正则表达式|3438271|public+String+plusOut(String+str,+String+word)+{
++word+=+java.util.regex.Pattern.quote(word);
++return+str.replaceAll("\\G((?:"+%2B+word+%2B+")*%2B).",+"$1%2B");
}|3438272|构造正则表达式\G((?:word)*%2B).，它或多或少地完成了solution+1正在做的事情：|3438273|3438274|\G确保匹配从前一个匹配留下的位置开始，off|unordered-list-item|3438275|((?:word)*%2B)挑选出0个或更多个word实例-如果有的话，这样我们就可以用$1替换它们。这里的关键是所有格量词*%2B，它强制正则表达式保留它找到的word的任何实例。否则，当字符串末尾出现word时，正则表达式将无法正常工作，因为匹配.|3438276|.的正则表达式回溯将不会是任何word的一部分，因为前一部分已经挑选出word的所有连续外观并禁止回溯。我们将用%2B|3438277|替换它|3438278|解决方案4:流媒体|3438279|public+String+plusOut(String+str,+String+word)+{
++return+String.join(word,+
++++Arrays.stream(str.split(java.util.regex.Pattern.quote(word),+-1))
++++++.map((String+s)+->+s.replaceAll("(?s:.)",+"%2B"))
++++++.collect(Collectors.toList()));
}|3438280|其思想是通过word拆分字符串，对其余部分进行替换，然后使用String.join方法将它们与word连接起来。|3438281|3438282|和上面一样，我们需要Pattern.quote来避免split将word解释为正则表达式。由于split在默认情况下会删除数组末尾的空字符串，因此我们需要在第二个参数中使用-1来使split保留这些空字符串。|3438283|然后我们在数组之外创建一个流，并将其余的替换为%2B的字符串。在Java11中，我们可以使用s+->+String.repeat(s.length())。|3438284|剩下的只是将流转换为一个迭代(在本例中为List)，并将它们连接起来以得到|3438285|3438286|entityMap^0|H|7|0|0|0|0|0|0|0|0|0|5|D|L|A|Y|4|0|8|2|0|0|7|F|0|0|0|2|0|0|C|L|4|16|2|1O|2|25|4|2Q|4|3D|1|0|0|1|F|4|Z|4|1K|1|0|0|0|0|6|4|U|B|1B|4|0|0|A|D|Q|5|W|4|1B|5|2E|2|2I|5|0|N|1|18|U|0|0|0^^$0|@$1|2|3|4|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|20|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|21|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|22|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|23|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|24|8|@]|D|@]|E|$]]|$1|U|3|V|5|N|7|25|8|@]|D|@]|E|$O|P]]|$1|W|3|X|5|6|7|26|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|27|8|@$9|28|A|29|B|C]|$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|2E|8|@$9|2F|A|2G|B|C]]|D|@]|E|$]]|$1|12|3|13|5|N|7|2H|8|@]|D|@]|E|$O|P]]|$1|14|3|15|5|6|7|2I|8|@$9|2J|A|2K|B|C]]|D|@]|E|$]]|$1|16|3|-4|5|6|7|2L|8|@]|D|@]|E|$]]|$1|17|3|18|5|19|7|2M|8|@$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|1A|3|1B|5|19|7|2P|8|@$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]|$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]|$9|32|A|33|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|19|7|34|8|@$9|35|A|36|B|C]|$9|37|A|38|B|C]|$9|39|A|3A|B|C]|$9|3B|A|3C|B|C]]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|3D|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|3E|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|N|7|3F|8|@]|D|@]|E|$O|P]]|$1|1K|3|1L|5|6|7|3G|8|@$9|3H|A|3I|B|C]|$9|3J|A|3K|B|C]|$9|3L|A|3M|B|C]]|D|@]|E|$]]|$1|1M|3|-4|5|6|7|3N|8|@]|D|@]|E|$]]|$1|1N|3|1O|5|19|7|3O|8|@$9|3P|A|3Q|B|C]|$9|3R|A|3S|B|C]|$9|3T|A|3U|B|C]|$9|3V|A|3W|B|C]|$9|3X|A|3Y|B|C]|$9|3Z|A|40|B|C]]|D|@]|E|$]]|$1|1P|3|1Q|5|19|7|41|8|@$9|42|A|43|B|C]|$9|44|A|45|B|C]]|D|@]|E|$]]|$1|1R|3|1S|5|19|7|46|8|@]|D|@]|E|$]]|$1|1T|3|-4|5|6|7|47|8|@]|D|@]|E|$]]|$1|1U|3|-4|5|6|7|48|8|@]|D|@]|E|$]]]|1V|$]]

Looks like this is the <code>plusOut</code> problem on CodingBat.

I had 3 solutions to this problem, and wrote a new streaming solution just for fun.

<h3>Solution 1: Loop and check</h3>

Create a StringBuilder out of the input string, and check for the word at every position. Replace the character if doesn't match, and skip the length of the word if found.

<pre><code>public String plusOut(String str, String word) {
 StringBuilder out = new StringBuilder(str);

 for (int i = 0; i &lt; out.length(); ) {
 if (!str.startsWith(word, i))
 out.setCharAt(i++, '+');
 else
 i += word.length();
 }

 return out.toString();
}
</code></pre>

This is probably the expected answer for a beginner programmer, though there is an assumption that the string doesn't contain any astral plane character, which would be represented by 2 char instead of 1.

<h3>Solution 2: Replace the word with a marker, replace the rest, then restore the word</h3>

<pre><code>public String plusOut(String str, String word) {
 return str.replaceAll(java.util.regex.Pattern.quote(word), "@").replaceAll("[^@]", "+").replaceAll("@", word);
}
</code></pre>

Not a proper solution since it assumes that a certain character or sequence of character doesn't appear in the string.

Note the use of <code>Pattern.quote</code> to prevent the <code>word</code> being interpreted as regex syntax by <code>replaceAll</code> method.

<h3>Solution 3: Regex with <code>\G</code></h3>

<pre><code>public String plusOut(String str, String word) {
 word = java.util.regex.Pattern.quote(word);
 return str.replaceAll("\\G((?:" + word + ")*+).", "$1+");
}
</code></pre>

Construct regex <code>\G((?:word)*+).</code>, which does more or less what solution 1 is doing:

<ul>
<li><code>\G</code> makes sure the match starts from where the previous match leaves off</li>
<li><code>((?:word)*+)</code> picks out 0 or more instance of <code>word</code> - if any, so that we can keep them in the replacement with <code>$1</code>. The key here is the possessive quantifier <code>*+</code>, which forces the regex to keep any instance of the <code>word</code> it finds. Otherwise, the regex will not work correctly when the <code>word</code> appear at the end of the string, as the regex backtracks to match <code>.</code></li>
<li><code>.</code> will not be part of any <code>word</code>, since the previous part already picks out all consecutive appearances of <code>word</code> and disallow backtrack. We will replace this with <code>+</code></li>
</ul>

<h3>Solution 4: Streaming</h3>

<pre><code>public String plusOut(String str, String word) {
 return String.join(word, 
 Arrays.stream(str.split(java.util.regex.Pattern.quote(word), -1))
 .map((String s) -&gt; s.replaceAll("(?s:.)", "+"))
 .collect(Collectors.toList()));
}
</code></pre>

The idea is to split the string by <code>word</code>, do the replacement on the rest, and join them back with <code>word</code> using <code>String.join</code> method.

<ul>
<li>Same as above, we need <code>Pattern.quote</code> to avoid <code>split</code> interpreting the <code>word</code> as regex. Since <code>split</code> by default removes empty string at the end of the array, we need to use <code>-1</code> in the second parameter to make <code>split</code> leave those empty strings alone.</li>
<li>Then we create a stream out of the array and replace the rest as strings of <code>+</code>. In Java 11, we can use <code>s -&gt; String.repeat(s.length())</code> instead.</li>
<li>The rest is just converting the Stream to an Iterable (List in this case) and joining them for the result</li>
</ul>

blocks|key|3224841|text|绝对只是为了好玩，一个使用CharBuffer的解决方案(出乎意料的是，它比我最初希望的要多得多)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3224842|private+static+String+plusOutCharBuffer(String+input,+String+match)+{
++++int+size+=+match.length();
++++CharBuffer+cb+=+CharBuffer.wrap(input.toCharArray());
++++CharBuffer+word+=+CharBuffer.wrap(match);

++++int+x+=+0;
++++for+(;+cb.remaining()+>+0;)+{
++++++++if+(!cb.subSequence(0,+size+<+cb.remaining()+?+size+:+cb.remaining()).equals(word))+{
++++++++++++cb.put(x,+'%2B');
++++++++++++cb.clear().position(%2B%2Bx);
++++++++}+else+{
++++++++++++cb.clear().position(x+=+x+%2B+size);
++++++++}
++++}

++++return+cb.clear().toString();
}|code-block|syntax|javascript|3224843|entityMap^0|D|A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Absolutely just for the fun of it, a solution using <code>CharBuffer</code> (unexpectedly it took a lot more that I initially hoped for):

<pre><code>private static String plusOutCharBuffer(String input, String match) {
 int size = match.length();
 CharBuffer cb = CharBuffer.wrap(input.toCharArray());
 CharBuffer word = CharBuffer.wrap(match);

 int x = 0;
 for (; cb.remaining() &gt; 0;) {
 if (!cb.subSequence(0, size &lt; cb.remaining() ? size : cb.remaining()).equals(word)) {
 cb.put(x, '+');
 cb.clear().position(++x);
 } else {
 cb.clear().position(x = x + size);
 }
 }

 return cb.clear().toString();
}
</code></pre>

blocks|key|396178|text|要做到这一点，你需要一个野兽般的模式。假设您正在以以下测试用例为例进行操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|396179|plusOut("abXYxyzXYZ",+"XYZ")+→+"%2B%2B%2B%2B%2B%2B%2BXYZ"|code-block|syntax|javascript|396180|您需要做的是在您的模式中构建一系列子句，以便一次匹配一个字符：|396181|不带"X“、"Y”或"Z“的任何字符--+[%5EXYZ]|offset|length|style|CODE|396182|Any+"X”不带"YZ“--+X(?!YZ)|unordered-list-item|396183|
|396184|Any+"Y”不带"X“--+(?<!X)Y|396185|396186|Any+"Y”不带"Z“--+Y(?!Z)|396187|396188|Any+"Z”不带"XY“--+(?<!XY)Z|396189|396190|可以在这里找到这种替代的示例：https://regex101.com/r/jK5wU3/4|396191|这是一个如何工作的示例(大多数情况下没有优化，但它是有效的)：|396192|import+java.util.regex.Pattern;

public+class+Test+{

++++public+static+void+plusOut(String+text,+String+exclude)+{

++++++++StringBuilder+pattern+=+new+StringBuilder("");
++++++++for+(int+i=0;+i<exclude.length();+i%2B%2B)+{

++++++++++++Character+target++++=+exclude.charAt(i);
++++++++++++String+prefix+++++++=+(i+>+0)+?+exclude.substring(0,+i)+:+"";
++++++++++++String+postfix++++++=+(i+<+exclude.length()+-+1)+?+exclude.substring(i%2B1)+:+"";

++++++++++++//+add+the+look-behind+(?<!X)Y
++++++++++++if+(!prefix.isEmpty())+{
++++++++++++++++pattern.append("(?<!").append(Pattern.quote(prefix)).append(")")
++++++++++++++++++++++++.append(Pattern.quote(target.toString())).append("%7C");
++++++++++++}

++++++++++++//+add+the+look-ahead+X(?!YZ)
++++++++++++if+(!postfix.isEmpty())+{
++++++++++++++++pattern.append(Pattern.quote(target.toString()))
++++++++++++++++++++++++.append("(?!").append(Pattern.quote(postfix)).append(")%7C");
++++++++++++}

++++++++}

++++++++//+add+in+the+other+character+exclusion
++++++++pattern.append("[%5E"+%2B+Pattern.quote(exclude)+%2B+"]");

++++++++System.out.println(text.replaceAll(pattern.toString(),+"%2B"));

++++}

++++public+static+void+main(String++[]+args)+{

++++++++plusOut("12xy34",+"xy");
++++++++plusOut("12xy34",+"1");
++++++++plusOut("12xy34xyabcxy",+"xy");
++++++++plusOut("abXYabcXYZ",+"ab");
++++++++plusOut("abXYabcXYZ",+"abc");
++++++++plusOut("abXYabcXYZ",+"XY");
++++++++plusOut("abXYxyzXYZ",+"XYZ");
++++++++plusOut("--%2B%2Bab",+"%2B%2B");
++++++++plusOut("aaxxxxbb",+"xx");
++++++++plusOut("123123",+"3");

++++}

}|396193|更新:即使这样也不太有效，因为它不能处理仅仅是重复字符的排除，比如"xx“。正则表达式绝对不是最合适的工具，但我认为它可能是可能的。在仔细研究之后，我甚至不确定是否存在一种模式可以使这种方法工作。|396194|entityMap|0|LINK|mutability|MUTABLE|url|https://regex101.com/r/jK5wU3/4^0|0|0|0|L|6|0|G|7|0|0|F|7|0|0|F|6|0|0|G|8|0|0|F|V|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1K|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1L|8|@$K|1M|L|1N|M|N]]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1O|8|@$K|1P|L|1Q|M|N]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1R|8|@]|9|@]|A|$]]|$1|T|3|U|5|Q|7|1S|8|@$K|1T|L|1U|M|N]]|9|@]|A|$]]|$1|V|3|S|5|6|7|1V|8|@]|9|@]|A|$]]|$1|W|3|X|5|Q|7|1W|8|@$K|1X|L|1Y|M|N]]|9|@]|A|$]]|$1|Y|3|S|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|Z|3|10|5|Q|7|20|8|@$K|21|L|22|M|N]]|9|@]|A|$]]|$1|11|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|24|8|@]|9|@$K|25|L|26|1|27]]|A|$]]|$1|14|3|15|5|6|7|28|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|29|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|2A|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H]]]]

To make this work you need a beast of a pattern. Let's say you you are operating on the following test case as an example:

<pre><code>plusOut("abXYxyzXYZ", "XYZ") → "+++++++XYZ"
</code></pre>

What you need to do is build a series of clauses in your pattern to match a single character at a time:

<ul>
<li>Any character that is NOT "X", "Y" or "Z" -- <code>[^XYZ]</code></li>
<li>Any "X" not followed by "YZ" -- <code>X(?!YZ)</code></li>
<li>Any "Y" not preceded by "X" -- <code>(?&lt;!X)Y</code></li>
<li>Any "Y" not followed by "Z" -- <code>Y(?!Z)</code></li>
<li>Any "Z" not preceded by "XY" -- <code>(?&lt;!XY)Z</code></li>
</ul>

An example of this replacement can be found here: <a href="https://regex101.com/r/jK5wU3/4" rel="nofollow noreferrer">https://regex101.com/r/jK5wU3/4</a>

Here is an example of how this might work (most certainly not optimized, but it works):

<pre><code>import java.util.regex.Pattern;

public class Test {

 public static void plusOut(String text, String exclude) {

 StringBuilder pattern = new StringBuilder("");
 for (int i=0; i&lt;exclude.length(); i++) {

 Character target = exclude.charAt(i);
 String prefix = (i &gt; 0) ? exclude.substring(0, i) : "";
 String postfix = (i &lt; exclude.length() - 1) ? exclude.substring(i+1) : "";

 // add the look-behind (?&lt;!X)Y
 if (!prefix.isEmpty()) {
 pattern.append("(?&lt;!").append(Pattern.quote(prefix)).append(")")
 .append(Pattern.quote(target.toString())).append("|");
 }

 // add the look-ahead X(?!YZ)
 if (!postfix.isEmpty()) {
 pattern.append(Pattern.quote(target.toString()))
 .append("(?!").append(Pattern.quote(postfix)).append(")|");
 }

 }

 // add in the other character exclusion
 pattern.append("[^" + Pattern.quote(exclude) + "]");

 System.out.println(text.replaceAll(pattern.toString(), "+"));

 }

 public static void main(String [] args) {

 plusOut("12xy34", "xy");
 plusOut("12xy34", "1");
 plusOut("12xy34xyabcxy", "xy");
 plusOut("abXYabcXYZ", "ab");
 plusOut("abXYabcXYZ", "abc");
 plusOut("abXYabcXYZ", "XY");
 plusOut("abXYxyzXYZ", "XYZ");
 plusOut("--++ab", "++");
 plusOut("aaxxxxbb", "xx");
 plusOut("123123", "3");

 }

}
</code></pre>

UPDATE: Even this doesn't quite work because it can't deal with exclusions that are just repeated characters, like "xx". Regular expressions are most definitely not the right tool for this, but I thought it might be possible. After poking around, I'm not so sure a pattern even exists that might make this work.

blocks|key|3224867|text|解决方案中的问题是，您放置了一组实例字符串str.replaceAll("[%5Estr]","%2B")，它将从变量str中排除任何字符，但这并不能解决您的问题|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3224868|EX：当你尝试str.replaceAll("[%5EXYZ]","%2B")时，它会从你的替换方法中排除character+X，character+Y和character+Z的任何组合，所以你会得到"%2B%2BXY%2B%2B%2BXYZ“。|BOLD|3224869|实际上，您应该在str.replaceAll中排除一个字符序列。|3224870|您可以通过使用捕获组字符(如(XYZ)+)，然后使用负向先行来匹配不包含字符的字符串序列：%5E((?!XYZ).)*$|3224871|有关这个问题的更多信息，请查看此solution，但您应该知道，直接查找正则表达式可能会很复杂。|3224872|对于这个问题，我找到了两个简单的解决方案：|3224873|解决方案1|3224874|您可以实现一个方法，将除给定字符串的实例之外的所有字符替换为'%2B‘：|3224875|String+exWord+=+"XYZ";
String+str+=+"abXYxyzXYZ";

for(int+i+=+0;+i+<+str.length();+i%2B%2B){
++++//+exclude+any+instance+string+of+exWord+from+replacing+process+in+str
++++if(str.substring(i,+str.length()).indexOf(exWord)+%2B+i+==+i){
++++++++i+=+i+%2B+exWord.length()-1;
++++}
++++else{
++++++++str+=+str.substring(0,i)+%2B+"%2B"+%2B+str.substring(i%2B1);//replace+each+character+with+'%2B'+symbol
++++}
}+++++++++++++|code-block|syntax|javascript|3224876|注意：str.substring(i,+str.length()).indexOf(exWord)+%2B+i此if语句将从替换str中的进程中排除exWord的任何实例字符串。|3224877|输出|3224878|%2B%2B%2B%2B%2B%2B%2BXYZ|3224879|解决方案2|3224880|您可以使用ReplaceAll方法尝试这种方法，它不需要任何复杂的正则表达式：|3224881|String+exWord+=+"XYZ";
String+str+=+"abXYxyzXYZ";

str+=+str.replaceAll(exWord,"*");+//+replace+instance+string+with+*+symbol
str+=+str.replaceAll("[%5E*]","%2B");+//+replace+all+characters+with+%2B+symbol+except+*+
str+=+str.replaceAll("\\*",exWord);+//+replace+*+symbol+with+instance+string|3224882|注意：只有当您的输入字符串str不包含任何*符号时，此解决方案才有效。|3224883|此外，还应该转义短语实例字符串exWord中的正则表达式中具有特殊含义的任何字符，如：exWord+=+"%2B%2B"。|3224884|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/406408/5169186^0|L|S|1J|3|0|0|2|7|S|1N|1|1Z|1|2B|1|2P|A|0|8|E|0|7|3|Q|4|E|5|19|D|0|G|8|0|0|0|0|5|0|V|1|0|0|0|2|3|1E|1Q|3|20|6|0|0|2|0|0|0|5|0|5|A|0|0|0|2|D|3|L|1|0|F|6|17|D|0^^$0|@$1|2|3|4|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1S|8|@$9|1T|A|1U|B|H]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|25|8|@$9|26|A|27|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|28|8|@$9|29|A|2A|B|H]|$9|2B|A|2C|B|H]|$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|2H|8|@]|D|@$9|2I|A|2J|1|2K]]|E|$]]|$1|O|3|P|5|6|7|2L|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2M|8|@$9|2N|A|2O|B|H]]|D|@]|E|$]]|$1|S|3|T|5|6|7|2P|8|@$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|U|3|V|5|W|7|2S|8|@]|D|@]|E|$X|Y]]|$1|Z|3|10|5|6|7|2T|8|@$9|2U|A|2V|B|H]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]]|D|@]|E|$]]|$1|11|3|12|5|6|7|32|8|@$9|33|A|34|B|H]]|D|@]|E|$]]|$1|13|3|14|5|W|7|35|8|@]|D|@]|E|$X|Y]]|$1|15|3|16|5|6|7|36|8|@$9|37|A|38|B|H]]|D|@]|E|$]]|$1|17|3|18|5|6|7|39|8|@$9|3A|A|3B|B|H]]|D|@]|E|$]]|$1|19|3|1A|5|W|7|3C|8|@]|D|@]|E|$X|Y]]|$1|1B|3|1C|5|6|7|3D|8|@$9|3E|A|3F|B|H]|$9|3G|A|3H|B|C]|$9|3I|A|3J|B|C]]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|3K|8|@$9|3L|A|3M|B|C]|$9|3N|A|3O|B|C]]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|3P|8|@]|D|@]|E|$]]]|1G|$1H|$5|1I|1J|1K|E|$1L|1M]]]]

The problem in your solution that you put a set of instance string <code>str.replaceAll("[^str]","+")</code> which it will exclude any character from the variable <code>str</code> and that will not solve your problem 

EX: when you try <code>str.replaceAll("[^XYZ]","+")</code> it will exclude any combination of character <code>X</code> , character <code>Y</code> and character <code>Z</code> from your replacing method so you will get "<code>++XY+++XYZ</code>". 

Actually you should exclude a sequence of characters instead in <code>str.replaceAll</code>.

You can do it by using capture group of characters like <code>(XYZ)</code> then use a negative lookahead to match a string which does not contain characters sequence : <code>^((?!XYZ).)*$</code>

Check this <a href="https://stackoverflow.com/a/406408/5169186">solution</a> for more info about this problem but you should know that it may be complicated to find regular expression to do that directly.

I have found two simple solutions for this problem :

Solution 1:

You can implement a method to replace all characters with '<code>+</code>' except the instance of given string:

<pre><code>String exWord = "XYZ";
String str = "abXYxyzXYZ";

for(int i = 0; i &lt; str.length(); i++){
 // exclude any instance string of exWord from replacing process in str
 if(str.substring(i, str.length()).indexOf(exWord) + i == i){
 i = i + exWord.length()-1;
 }
 else{
 str = str.substring(0,i) + "+" + str.substring(i+1);//replace each character with '+' symbol
 }
} 
</code></pre>

Note : <code>str.substring(i, str.length()).indexOf(exWord) + i</code> this if statement will exclude any instance string of <code>exWord</code> from replacing process in <code>str</code>.

Output:

<pre><code>+++++++XYZ
</code></pre>

Solution 2:

You can try this Approach using ReplaceAll method and it doesn't need any complex regular expression:

<pre><code>String exWord = "XYZ";
String str = "abXYxyzXYZ";

str = str.replaceAll(exWord,"*"); // replace instance string with * symbol
str = str.replaceAll("[^*]","+"); // replace all characters with + symbol except * 
str = str.replaceAll("\\*",exWord); // replace * symbol with instance string
</code></pre>

Note : This solution will work only if your input string <code>str</code> doesn't contain any <code>*</code> symbol.

Also you should escape any character with a special meaning in a regular expression in phrase instance string <code>exWord</code> like : <code>exWord = "++"</code>.

I have the following problem which states

<blockquote>
 Replace all characters in a string with <code>+</code> symbol except instances of the given string in the method
</blockquote>

so for example if the string given was <code>abc123efg</code> and they want me to replace every character except every instance of <code>123</code> then it would become <code>+++123+++</code>.

I figured a regular expression is probably the best for this and I came up with this.

<pre><code>str.replaceAll("[^str]","+") 
</code></pre>

where str is a variable, but its not letting me use the method without putting it in quotations. If I just want to replace the variable string str how can I do that? I ran it with the string manually typed and it worked on the method, but can I just input a variable?

as of right now I believe its looking for the string "str" and not the variable string.

Here is the output its right for so many cases except for two :(

<a href="https://i.stack.imgur.com/Ic9Ni.png" rel="noreferrer"><img src="https://i.stack.imgur.com/Ic9Ni.png" alt="enter image description here"></a>

List of open test cases:

<pre><code>plusOut("12xy34", "xy") → "++xy++"
plusOut("12xy34", "1") → "1+++++"
plusOut("12xy34xyabcxy", "xy") → "++xy++xy+++xy"
plusOut("abXYabcXYZ", "ab") → "ab++ab++++"
plusOut("abXYabcXYZ", "abc") → "++++abc+++"
plusOut("abXYabcXYZ", "XY") → "++XY+++XY+"
plusOut("abXYxyzXYZ", "XYZ") → "+++++++XYZ"
plusOut("--++ab", "++") → "++++++"
plusOut("aaxxxxbb", "xx") → "++xxxx++"
plusOut("123123", "3") → "++3++3"
</code></pre>

Java regex: Replace all characters with `+` except instances of a given string

我有以下问题，它说明将字符串中的所有字符替换为+符号，但方法中给定字符串的实例除外例如，如果给定的字符串是abc123efg，而他们希望我替换除123实例之外的所有字符，那么它将变为+++123+++。我认为正则表达式可能是最好的，所以我想出了这个。str.replaceAll("[^str]","+") 其中str是...

问Java regex:将除给定字符串实例之外的所有字符替换为`+`
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java regex:将除给定字符串实例之外的所有字符替换为`+`EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java regex:将除给定字符串实例之外的所有字符替换为`+`
EN