空格匹配正则表达式 - Java

Question

正则表达式的 Java API 指出 \ s 将匹配空白。因此正则表达式 \\s\\s 应匹配两个空格。

Pattern whitespace = Pattern.compile("\\s\\s");
matcher = whitespace.matcher(modLine);
while (matcher.find()) matcher.replaceAll(" ");

这样做的目的是用单个空格替换两个连续空格的所有实例。然而这实际上不起作用。

我对正则表达式或术语“空白”有严重误解吗？

Answer 1

您不能在 Java 中使用 \s 来匹配其自身本机字符集上的空格，因为 Java 不支持 Unicode 空格属性 — 尽管这样做是严格要求满足 UTS#18 的 RL1.2！ 唉，它所拥有的并不符合标准。

Unicode 定义了 26 个代码点为 \p{White_Space}：其中 20 个是各种 \pZ GeneralCategory=Separator，其余 6 个是 \p{Cc} GeneralCategory=Control。

空白是一种相当稳定的属性，而且这些空白几乎永远存在。即便如此，Java 没有符合 Unicode 标准的属性，因此您必须使用如下代码：

String whitespace_chars =  ""       /* dummy empty string for homogeneity */
                        + "\\u0009" // CHARACTER TABULATION
                        + "\\u000A" // LINE FEED (LF)
                        + "\\u000B" // LINE TABULATION
                        + "\\u000C" // FORM FEED (FF)
                        + "\\u000D" // CARRIAGE RETURN (CR)
                        + "\\u0020" // SPACE
                        + "\\u0085" // NEXT LINE (NEL) 
                        + "\\u00A0" // NO-BREAK SPACE
                        + "\\u1680" // OGHAM SPACE MARK
                        + "\\u180E" // MONGOLIAN VOWEL SEPARATOR
                        + "\\u2000" // EN QUAD 
                        + "\\u2001" // EM QUAD 
                        + "\\u2002" // EN SPACE
                        + "\\u2003" // EM SPACE
                        + "\\u2004" // THREE-PER-EM SPACE
                        + "\\u2005" // FOUR-PER-EM SPACE
                        + "\\u2006" // SIX-PER-EM SPACE
                        + "\\u2007" // FIGURE SPACE
                        + "\\u2008" // PUNCTUATION SPACE
                        + "\\u2009" // THIN SPACE
                        + "\\u200A" // HAIR SPACE
                        + "\\u2028" // LINE SEPARATOR
                        + "\\u2029" // PARAGRAPH SEPARATOR
                        + "\\u202F" // NARROW NO-BREAK SPACE
                        + "\\u205F" // MEDIUM MATHEMATICAL SPACE
                        + "\\u3000" // IDEOGRAPHIC SPACE
                        ;        
/* A \s that actually works for Java’s native character set: Unicode */
String     whitespace_charclass = "["  + whitespace_chars + "]";    
/* A \S that actually works for  Java’s native character set: Unicode */
String not_whitespace_charclass = "[^" + whitespace_chars + "]";

现在您可以使用 whitespace_charclass + "+" 作为 中的模式替换全部。

---

抱歉这一切。 Java 的正则表达式在其自己的本机字符集上不能很好地工作，因此您确实必须跳过异国情调才能使它们工作。

如果您认为空白不好，您应该看看需要做什么才能让 \w 和 \b 最终表现正常！

是的，这是可能的，是的，这是一个令人头脑麻木的混乱。这甚至是慈善事业。获得符合标准的 Java 正则表达式库的最简单方法是将 JNI 转移到 ICU 的东西。这就是 Google 对 Android 所做的事情，因为 OraSun 的不符合标准。

如果你不想这样做，但仍想坚持使用 Java，我有一个我编写的前端正则表达式重写库，可以“修复”Java 的模式，至少让它们符合 UTS#18 中的 RL1.2a，Unicode 正则表达式。

Answer 2

是的，您需要获取 matcher.replaceAll() 的结果：

String result = matcher.replaceAll(" ");
System.out.println(result);

Answer 3

对于 Java（不是 php，不是 javascript，不是任何其他）：

txt.replaceAll("\\p{javaSpaceChar}{2,}"," ")

Answer 4

自从这个问题首次提出以来，Java 已经不断发展。您可以使用 \p{Zs} 组来匹配所有形式的 unicode 空格字符。

因此，如果您想用普通空格替换一个或多个奇异空格，您可以这样做：

String txt = "whatever my string is";
String newTxt = txt.replaceAll("\\p{Zs}+", " ");

同样值得了解的是，如果您使用过 trim() 字符串函数，您应该看一下 (相对较新的）字符串上的 strip()、stripLeading() 和 stripTrailing() 函数。它们可以帮助您修剪掉各种松散的空白字符。有关包含哪些空格的更多信息，请参阅 Java 的 Character.isWhitespace() 函数。

Answer 5

要匹配任何空白字符，您可以使用

Pattern whitespace = Pattern.compile("\\s", Pattern.UNICODE_CHARACTER_CLASS);

Pattern.UNICODE_CHARACTER_CLASS 选项“启用预定义字符类和 POSIX 字符类的 Unicode 版本”，然后“符合Unicode 技术标准 #18：Unicode 正则表达式 附件 C：兼容性属性”。

还可以使用 (?U) 嵌入标志表达式启用相同的行为。例如，如果您想使用正则表达式替换/删除 Java 中的所有 Unicode 空格，您可以使用

String result = text.replaceAll("(?U)\\s+", ""); // removes all whitespaces
String result = text.replaceAll("(?U)\\s", "-"); // replaces each single whitespace with -
String result = text.replaceAll("(?U)\\s+", "-"); // replaces chunks of one or more consecutive whitespaces with a single -
String result = text.replaceAll("(?U)\\G\\s", "-"); // replaces each single whitespace at the start of string with -

查看 Java 在线演示：

String text = "\u00A0 \u00A0\tStart reading\u00A0here..."; // \u00A0 - non-breaking space
System.out.println("Text: '" + text + "'"); // => Text: '       Start reading here...'
System.out.println(text.replaceAll("(?U)\\s+", "")); // => Startreadinghere...
System.out.println(text.replaceAll("(?U)\\s", "-")); // => ----Start-reading-here...
System.out.println(text.replaceAll("(?U)\\s+", "-")); // => -Start-reading-here...
System.out.println(text.replaceAll("(?U)\\G\\s", "-")); // => ----Start reading here... 

Answer 6

似乎对我有用：

String s = "  a   b      c";
System.out.println("\""  + s.replaceAll("\\s\\s", " ") + "\"");

将打印：

" a  b   c"

我认为您打算这样做而不是您的代码：

Pattern whitespace = Pattern.compile("\\s\\s");
Matcher matcher = whitespace.matcher(s);
String result = "";
if (matcher.find()) {
    result = matcher.replaceAll(" ");
}

System.out.println(result);

Answer 7

当我向 Regexbuddy（正则表达式开发应用程序）论坛发送问题时，我得到了对 \s Java 问题的更准确答复：

“消息作者：Jan Goyvaerts

在 Java 中，简写 \s、\d 和 \w 仅包含 ASCII ... 这不是 Java 中的错误，而只是使用正则表达式时需要注意的众多事项之一。要匹配所有 Unicode 空格和换行符，可以使用 [\s\。 Java 中的 p{Z}] 尚不支持 Java 特定的属性，例如 \p{javaSpaceChar} （与 [\s\p{Z}] 匹配完全相同的字符）

。如果输入仅是 ASCII，则将匹配两个空格真正的问题在于 OP 的代码，正如该问题中接受的答案所指出的那样。”

Answer 8

Pattern whitespace = Pattern.compile("\\s\\s");
matcher = whitespace.matcher(modLine);

boolean flag = true;
while(flag)
{
 //Update your original search text with the result of the replace
 modLine = matcher.replaceAll(" ");
 //reset matcher to look at this "new" text
 matcher = whitespace.matcher(modLine);
 //search again ... and if no match , set flag to false to exit, else run again
 if(!matcher.find())
 {
 flag = false;
 }
}

Answer 9

为了您的目的，您可以使用此片段：

import org.apache.commons.lang3.StringUtils;

StringUtils.normalizeSpace(string);

这会将间距标准化为单个，并且还会去除开头和结尾的空格。

String sampleString = "Hello    world!";
sampleString.replaceAll("\\s{2}", " "); // replaces exactly two consecutive spaces
sampleString.replaceAll("\\s{2,}", " "); // replaces two or more consecutive white spaces

Answer 10

您可以使用更简单的：

String out = in.replaceAll(" {2}", " ");

Answer 11

在 RE 中使用空格很痛苦，但我相信它们有效。 OP的问题也可以使用StringTokenizer或split()方法来解决。但是，要使用 RE（取消注释 println() 以查看匹配器如何分解字符串），这里有一个示例代码：

import java.util.regex.*;

public class Two21WS {
    private String  str = "";
    private Pattern pattern = Pattern.compile ("\\s{2,}");  // multiple spaces

    public Two21WS (String s) {
            StringBuffer sb = new StringBuffer();
            Matcher matcher = pattern.matcher (s);
            int startNext = 0;
            while (matcher.find (startNext)) {
                    if (startNext == 0)
                            sb.append (s.substring (0, matcher.start()));
                    else
                            sb.append (s.substring (startNext, matcher.start()));
                    sb.append (" ");
                    startNext = matcher.end();
                    //System.out.println ("Start, end = " + matcher.start()+", "+matcher.end() +
                    //                      ", sb: \"" + sb.toString() + "\"");
            }
            sb.append (s.substring (startNext));
            str = sb.toString();
    }

    public String toString () {
            return str;
    }

    public static void main (String[] args) {
            String tester = " a    b      cdef     gh  ij   kl";
            System.out.println ("Initial: \"" + tester + "\"");
            System.out.println ("Two21WS: \"" + new Two21WS(tester) + "\"");
}}

它会生成以下内容（使用 javac 编译并在命令提示符下运行）：

% java Two21WS
首字母：“ab cdef gh ij kl”
Two21WS：“ab cdef gh ij kl”