Regex di corrispondenza degli spazi vuoti - Java

L'API Java per le espressioni regolari indica che \scorrisponderanno agli spazi. Quindi la regex \\s\\sdovrebbe corrispondere a due spazi.

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

Lo scopo è sostituire tutte le istanze di due spazi bianchi consecutivi con un unico spazio. Tuttavia questo non funziona effettivamente.

Sto avendo un grave fraintendimento delle regex o del termine "spazi bianchi"?

Sì, devi prendere il risultato di matcher.replaceAll():

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

Non è possibile utilizzarlo \sin Java per abbinare lo spazio bianco sul proprio set di caratteri nativi, perché Java non supporta la proprietà dello spazio bianco Unicode, anche se è strettamente necessario per soddisfare RL1.2 di UTS # 18! Quello che ha non è conforme agli standard, ahimè.

Unicode definisce 26 punti di codice come \p{White_Space}: 20 di loro sono vari tipi di \pZ GeneralCategory = Separator , e i restanti 6 sono\p{Cc} GeneralCategory = Control .

Lo spazio bianco è una proprietà piuttosto stabile e quelle stesse esistono praticamente da sempre. Anche così, Java non ha proprietà conformi allo standard Unicode per questi, quindi devi invece usare codice come questo:

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 + "]";

Ora puoi usare whitespace_charclass + "+" come modello nel tuo file replaceAll.

Mi dispiace per tutto questo. Le regex di Java semplicemente non funzionano molto bene sul proprio set di caratteri nativi, quindi devi davvero saltare attraverso cerchi esotici per farle funzionare.

E se pensi che lo spazio bianco sia negativo, dovresti vedere cosa devi fare per ottenerlo \w e \bfinalmente comportarti correttamente!

Sì, è possibile, e sì, è un casino stupefacente. Anche questo è caritatevole. Il modo più semplice per ottenere una libreria regex conforme agli standard per Java è utilizzare JNI per le cose di ICU. Questo è quello che fa Google per Android, perché quello di OraSun non è all'altezza.

Se non vuoi farlo ma vuoi comunque restare con Java, ho una libreria di riscrittura regex front-end che ho scritto che "corregge" i pattern di Java, almeno per renderli conformi ai requisiti di RL1.2a in UTS # 18, espressioni regolari Unicode .

Per Java (non php, non javascript, non altri):

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

quando ho inviato una domanda a un forum Regexbuddy (applicazione per sviluppatori regex), ho ottenuto una risposta più precisa alla mia domanda su Java:

"Autore del messaggio: Jan Goyvaerts

In Java, le scorciatoie \ s, \ d e \ w includono solo caratteri ASCII. ... Questo non è un bug in Java, ma semplicemente una delle tante cose di cui devi essere consapevole quando lavori con le espressioni regolari. Per abbinare tutti gli spazi Unicode e le interruzioni di riga, puoi utilizzare [\ s \ p {Z}] in Java. RegexBuddy non supporta ancora le proprietà specifiche di Java come \ p {javaSpaceChar} (che corrisponde esattamente agli stessi caratteri di [\ s \ p {Z}]).

... \ s \ s corrisponderà a due spazi, se l'input è solo ASCII. Il vero problema è con il codice dell'OP, come viene sottolineato dalla risposta accettata in quella domanda. "

Sembra funzionare per me:

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

stamperà:

" a  b   c"

Penso che intendevi farlo al posto del tuo codice:

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

System.out.println(result);

Per il tuo scopo puoi usare questo snnippet:

import org.apache.commons.lang3.StringUtils;

StringUtils.normalizeSpace(string);

Questo normalizzerà la spaziatura a singola e rimuoverà anche gli spazi bianchi iniziali e finali.

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

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;
 }
}

Java si è evoluto da quando questo problema è stato sollevato per la prima volta. Puoi abbinare tutti i tipi di caratteri di spazio Unicode utilizzando il \p{Zs}gruppo.

Quindi, se volessi sostituire uno o più spazi esotici con uno spazio semplice, potresti farlo:

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

Inoltre vale la pena conoscere, se hai utilizzato la trim()funzione di stringa si dovrebbe dare uno sguardo alla (relativamente nuovo) strip(), stripLeading()e le stripTrailing()funzioni sulle stringhe. Può aiutarti a tagliare tutti i tipi di caratteri di spazio bianco scoppiettanti. Per ulteriori informazioni su cosa è incluso lo spazio, vedere la Character.isWhitespace()funzione Java .

L'uso degli spazi bianchi in RE è un problema, ma credo che funzionino. Il problema dell'OP può anche essere risolto usando StringTokenizer o il metodo split (). Tuttavia, per utilizzare RE (rimuovere il commento da println () per vedere come il matcher sta spezzando la stringa), ecco un codice di esempio:

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) + "\"");
}}

Produce quanto segue (compilare con javac ed eseguire al prompt dei comandi):

% java Two21WS Iniziale: "ab cdef gh ij kl" Two21WS: "ab cdef gh ij kl"