wake-up-neo.net

Entfernen Sie alle leeren Zeilen

Ich dachte, das war nicht so schwer, aber ich möchte alle leeren Zeilen (oder Zeilen, die nur Leerzeichen und Tabulatoren in Java enthalten) mit String.replaceAll entfernen.

Mein Regex sieht so aus:

s = s.replaceAll ("^[ |\t]*\n$", "");

Aber es geht nicht.

Ich sah mich um, fand aber nur Regex zum Entfernen von leeren Zeilen ohne Leerzeichen oder Tabulatoren.

28
reox

Versuche dies:

String text = "line 1\n\nline 3\n\n\nline 5";
String adjusted = text.replaceAll("(?m)^[ \t]*\r?\n", "");
// ...

Beachten Sie, dass der Regex [ |\t] einem Leerzeichen, einem Tabulator oder einem Pipe-Zeichen entspricht.

BEARBEITEN

B.t.w., würde der Regex (?m)^\s+$ auch den Trick tun.

71
Bart Kiers

Ich kenne die Syntax für reguläre Ausdrücke in Java nicht, aber /^\s*$[\n\r]{1,}/gm ist der Regex, nach dem Sie suchen.

Sie schreiben es wahrscheinlich so in Java:

s = s.replaceAll("(?m)^\\s*$[\n\r]{1,}", "");

Ich habe es mit JavaScript getestet und es funktioniert gut.

4
Alin Purcaru

Ich bin kein Java-Programmierer im Alltag, daher bin ich überrascht, dass es im JDK keinen einfacheren Weg gibt als eine Regex.

Sowieso,

s = s.replaceAll("\n+", "\n");

wäre ein bisschen einfacher.

Update:

Entschuldigung, ich habe vermisst, dass Sie auch Leerzeichen und Tabulatoren entfernen wollten.

s = s.replaceAll("\n[ \t]*\n", "\n");

Würde funktionieren, wenn Sie konsistente Zeilenumbrüche haben. Wenn nicht, möchten Sie vielleicht in Erwägung ziehen, sie einheitlich zu gestalten. Z.B.:

s = s.replaceAll("[\n\r]+", "\n");
s = s.replaceAll("\n[ \t]*\n", "\n");
3
morganwahl

Sie können leere Zeilen mit folgendem Code aus Ihrem Code entfernen:

String test = plainTextWithEmptyLines.replaceAll("[\\\r\\\n]+","");

plainTextWithEmptyLines bezeichnet hier die Zeichenfolge mit den leeren Zeilen. [\\\r\\\n] ist das Regex-Muster, mit dem leere Zeilenumbrüche identifiziert werden.

3
Manvendra_0611

Wenn Sie die Zeilen aus Microsoft Office, Windows oder einem Texteditor entfernen möchten, der das Rendern von regulären Ausdrücken unterstützt:

 1. Press <kbd>Ctrl</kbd> + <kbd>F</kbd>.
 2. Check the regular expression checkbox
 3. Enter Expression ^\s*\n into the find box as it is.

Sie sehen, dass alle schwarzen Felder in Ihrem Editor verschwinden ...

1
nitesh

Ich habe etwas Code ohne regexp, importiere einfach org.Apache.commons.lang3.StringUtils;

  File temporaire = new File("temp.txt");
  try {
    Scanner scanner = new Scanner(yourfile);
    BufferedWriter bw = new BufferedWriter(new FileWriter(temporaire));
    while (scanner.hasNextLine()) {
      String line = StringUtils.stripEnd(scanner.nextLine(),null); // Clean blanks at the end of the line
      if (StringUtils.isNotBlank(line)) {
        bw.write(line); // Keep the line only if not blank
        if (scanner.hasNextLine()){
          // Go to next line (Win,Mac,Unix) if there is one
          bw.write(System.getProperty("line.separator"));
        }
      }
      bw.flush();
    }
    scanner.close();
    bw.close();
    fichier.delete();
    temporaire.renameTo(fichier);
  }
  catch (FileNotFoundException e) {
    System.out.println(e.getMessage());
  }
  catch (IOException e) {
    System.out.println(e.getMessage());
  }
}
1
zev

Bart Kierss Antwort fehlt der Edge-Fall, bei dem die letzte Zeile der Zeichenfolge leer ist oder Leerzeichen enthält.

Wenn du es versuchst

String text = "line 1\n\nline 3\n\n\nline 5\n "; // <-- Mind the \n plus space at the end!
String adjusted = text.replaceAll("(?m)^[ \t]*\r?\n", "");

sie erhalten einen String, der diesem entspricht

"line 1\nline 3\nline 5\n " // <-- MIND the \n plus space at the end!

als Ergebnis.

Ich habe die Antwort von Bart Kiers erweitert, um auch diesen Fall zu behandeln.

Mein Regex-Muster ist:

String pattern = "(?m)^\\s*\\r?\\n|\\r?\\n\\s*(?!.*\\r?\\n)";

Eine kleine Erklärung:

Der erste Teil des Musters ist grundsätzlich dasselbe wie Bart Kiers '. Es ist in Ordnung, aber es wird keine "leere" letzte Zeile oder letzte Zeile mit Whitespaces entfernt.

Dies liegt daran, dass eine letzte Zeile, die nur Leerzeichen enthält, nicht mit \\r?\\n endet und daher nicht abgeglichen/ersetzt werden würde. Wir brauchen etwas, um diesen Randfall auszudrücken. Hier kommt der zweite Teil (nach dem |) ins Spiel.

Es verwendet eine reguläre Ausdrucksspezialität: negative Lookahead. Das ist der (?!.*\\r?\\n)-Teil des Musters. (?! markiert den Anfang des Lookaheads. Sie könnten es folgendermaßen lesen: Passen Sie den regulären Ausdruck vor dem Lookahead an, wenn nicht die Zeichenfolge folgt, die als Zeichenfolge definiert ist, die nicht folgen darf. In unserem Fall: Kein Zeichen (null oder mehrmals), gefolgt von einem Wagenrücklauf (0 oder 1 Mal) und einer neuen Zeile: .*\\r?\\n. Der ) schließt den Lookahead. Der Lookahead selbst ist nicht Teil des Spiels.

Wenn ich das folgende Code-Snippet ausführen:

String pattern = "(?m)^\\s*\\r?\\n|\\r?\\n\\s*(?!.*\\r?\\n)";
String replacement = "";
String inputString =
        "\n" +
        "Line  2 - above line is empty without spaces\n" +
        "Line  3 - next is empty without whitespaces\n" +
        "\n" +
        "Line  5 - next line is with whitespaces\n" +
        "        \n" +
        "Line  7 - next 2 lines are \"empty\". First one with whitespaces.\n" +
        "        \r\n" +
        "\n" +
        "Line 10 - 3 empty lines follow. The 2nd one with whitespaces in it. One whitespace at the end of this line " +
        "\n" +
        "          \n" +
        "\n";

String ajdustedString = inputString.replaceAll(pattern, replacement);
System.out.println("inputString:");
System.out.println("+----");
System.out.println(inputString);
System.out.println("----+");
System.out.println("ajdustedString:");
System.out.println("+----");
System.out.print(ajdustedString); //MIND the "print" instead of "println"
System.out.println("|EOS"); //String to clearly mark the _E_nd _O_f the adjusted_S_tring
System.out.println("----+");

Ich bekomme:

 inputString: 
 + ----

 Zeile 2 - über Zeile ist leer ohne Leerzeichen 
 Zeile 3 - next ist leer ohne Leerzeichen 

 Zeile 5 - nächste Zeile ist mit Leerzeichen 

 Zeile 7 - die nächsten 2 Zeilen sind "leer". Zuerst mit Leerzeichen .


 Zeile 10 - 3 Leerzeilen folgen. Die zweite mit Whitespaces darin. Ein Leerzeichen am Ende dieser Zeile 



---- + 
 AjdustedString: 
 + ----
 Zeile 2 - über der Zeile ist leer ohne Leerzeichen 
 Zeile 3 - next ist leer ohne Leerzeichen 
 Zeile 5 - nächste Zeile ist mit Whitespaces 
 Zeile 7 - nächste 2 Zeilen sind "leer". Zuerst eine mit Whitespaces .
 Zeile 10 - 3 Leerzeilen folgen. Die zweite mit Whitespaces darin. Ein Leerzeichen am Ende dieser Zeile | EOS 
---- + 

Wenn Sie mehr über Lookahead/Lookbehind erfahren möchten, siehe Regex-Tutorial - Lookahead und Lookbehind Zero-Length Assertions:

0
kriddoff