Wie entferne ich Zeilenumbrüche aus einer Datei in Java?

Wie kann ich alle Zeilenumbrüche aus einer Zeichenfolge in Java so ersetzen, dass sie unter Windows und Linux funktionieren (dh keine betriebssystemspezifischen Probleme mit Wagenrücklauf / Zeilenvorschub / neue Zeile usw.)?

Ich habe es versucht (Anmerkung readFileAsString ist eine Funktion, die eine Textdatei in einen String liest):

String text = readFileAsString("textfile.txt");
text.replace("\n", "");

aber das scheint nicht zu funktionieren.

Wie kann das gemacht werden?

Sie müssen folgende textErgebnisse erzielen text.replace():

String text = readFileAsString("textfile.txt");
text = text.replace("\n", "").replace("\r", "");

Dies ist erforderlich, da Strings unveränderlich sind. Durch Aufrufen replacewird der ursprüngliche String nicht geändert, sondern es wird ein neuer zurückgegeben, der geändert wurde. Wenn Sie das Ergebnis nicht zuweisen text, geht dieser neue String verloren und der Müll wird gesammelt.

Der Newline-String für jede Umgebung wird abgerufen, indem Sie ihn aufrufen System.getProperty("line.separator").

Wie in anderen Antworten erwähnt, funktioniert Ihr Code in erster Linie nicht, da String.replace(...)das Ziel nicht geändert wird String. (Es kann nicht - Java-Zeichenfolgen sind unveränderlich!) Tatsächlich replacewird ein neues StringObjekt erstellt und zurückgegeben, wobei die Zeichen nach Bedarf geändert werden. Aber Ihr Code wirft dann das weg String...

Hier sind einige mögliche Lösungen. Welches am besten ist, hängt davon ab, was genau Sie versuchen.

// #1
text = text.replace("\n", "");

Entfernt einfach alle Zeilenumbruchzeichen. Dies ist nicht mit Windows- oder Mac-Leitungsbeendigungen möglich.

// #2
text = text.replace(System.getProperty("line.separator"), "");

Entfernt alle Leitungsterminatoren für die aktuelle Plattform. Dies ist nicht der Fall, wenn Sie versuchen, beispielsweise eine UNIX-Datei unter Windows zu verarbeiten, oder umgekehrt.

// #3
text = text.replaceAll("\\r|\\n", "");

Entfernt alle Windows-, UNIX- oder Mac-Zeilenabschlüsse. Wenn es sich bei der Eingabedatei jedoch um Text handelt, werden Wörter verkettet. z.B

Goodbye cruel
world.

wird

Goodbye cruelworld.

Vielleicht möchten Sie dies tatsächlich tun:

// #4
text = text.replaceAll("\\r\\n|\\r|\\n", " ");

Dies ersetzt jeden Zeilenabschluss durch ein Leerzeichen. Seit Java 8 können Sie dies auch tun:

// #5
text = text.replaceAll("\\R", " ");

Und wenn Sie mehrere Zeilentrennzeichen durch ein Leerzeichen ersetzen möchten:

// #6
text = text.replaceAll("\\R+", " ");

Wenn Sie nur Zeilenabschlüsse entfernen möchten, die auf dem aktuellen Betriebssystem gültig sind, können Sie Folgendes tun:

text = text.replaceAll(System.getProperty("line.separator"), "");

Wenn Sie sicherstellen möchten, dass alle Zeilentrennzeichen entfernt werden, können Sie dies folgendermaßen tun:

text = text.replaceAll("\\r|\\n", "");

Oder etwas ausführlicher, aber weniger regexy:

text = text.replaceAll("\\r", "").replaceAll("\\n", "");

Diese Funktion normalisiert alle Leerzeichen, einschließlich Zeilenumbrüche, auf einzelne Leerzeichen. Nicht genau das, wonach die ursprüngliche Frage gestellt hat, aber wahrscheinlich genau das, was in vielen Fällen benötigt wird:

import org.apache.commons.lang3.StringUtils;

final String cleansedString = StringUtils.normalizeSpace(rawString);

Das wäre effizient, denke ich

String s;
s = "try this\n try me.";
s.replaceAll("[\\r\\n]+", "")

str = str.replaceAll("\\r\\n|\\r|\\n", " ");

Funktionierte perfekt für mich, nachdem ich viel gesucht hatte, nachdem ich mit jeder anderen Zeile versagt hatte.

Zeilenumbrüche sind unter Windows / Linux / Mac nicht identisch. Sie sollten System.getProperties mit dem Attribut line.separator verwenden.

String text = readFileAsString("textfile.txt").replace("\n","");

.replace gibt eine neue Zeichenfolge zurück. Zeichenfolgen in Java sind unveränderlich.

Möglicherweise möchten Sie Ihre Datei mit einem lesen BufferedReader. Diese Klasse kann Eingaben in einzelne Zeilen aufteilen, die Sie nach Belieben zusammenstellen können. Die Funktionsweise BufferedReadererkennt Zeilenendkonventionen der Linux-, Windows- und MacOS-Welt automatisch, unabhängig von der aktuellen Plattform.

Daher:

BufferedReader br = new BufferedReader(
    new InputStreamReader("textfile.txt"));
StringBuilder sb = new StringBuilder();
for (;;) {
    String line = br.readLine();
    if (line == null)
        break;
    sb.append(line);
    sb.append(' ');   // SEE BELOW
}
String text = sb.toString();

Beachten Sie, dass der readLine()Zeilenabschluss nicht in der zurückgegebenen Zeichenfolge enthalten ist. Der obige Code fügt ein Leerzeichen hinzu, um zu vermeiden, dass das letzte Wort einer Zeile und das erste Wort der nächsten Zeile zusammengeklebt werden.

String text = readFileAsString("textfile.txt").replaceAll("\n", "");

Obwohl die Definition von trim () in der Oracle-Website "Gibt eine Kopie der Zeichenfolge zurück, wobei führende und nachfolgende Leerzeichen weggelassen werden".

In der Dokumentation wird nicht angegeben, dass auch neue Zeilenzeichen (führende und nachfolgende) entfernt werden.

Kurz gesagt, String text = readFileAsString("textfile.txt").trim();wird auch für Sie arbeiten. (Mit Java 6 überprüft)

Ich finde es seltsam, dass (Apache) StringUtils hier noch nicht behandelt wurde.

Mit der .replaceMethode können Sie alle Zeilenumbrüche (oder andere Vorkommen eines Teilstrings) aus einer Zeichenfolge entfernen

StringUtils.replace(myString, "\n", "");

Diese Zeile ersetzt alle Zeilenumbrüche durch die leere Zeichenfolge.

Da newline technisch gesehen ein Zeichen ist, können Sie optional die .replaceCharsMethode verwenden, die Zeichen ersetzt

StringUtils.replaceChars(myString, '\n', '');

Zu Ihrer Information, wenn Sie gleichzeitige Mehrzeilenbrüche durch einen einzelnen Zeilenumbruch ersetzen möchten, können Sie verwenden

myString.trim().replaceAll("[\n]{2,}", "\n")

Oder durch ein einzelnes Leerzeichen ersetzen

myString.trim().replaceAll("[\n]{2,}", " ")

Sie können Apache Commons IOUtils verwenden, um die Zeile zu durchlaufen und jede Zeile an StringBuilder anzuhängen. Und vergessen Sie nicht, den InputStream zu schließen

StringBuilder sb = new StringBuilder();
FileInputStream fin=new FileInputStream("textfile.txt");
LineIterator lt=IOUtils.lineIterator(fin, "utf-8");
while(lt.hasNext())
{
  sb.append(lt.nextLine());
}
String text = sb.toString();
IOUtils.closeQuitely(fin);

Sie können generische Methoden verwenden, um jedes Zeichen durch ein beliebiges Zeichen zu ersetzen.

public static void removeWithAnyChar(String str, char replceChar,
        char replaceWith) {
    char chrs[] = str.toCharArray();
    int i = 0;
    while (i < chrs.length) {

        if (chrs[i] == replceChar) {
            chrs[i] = replaceWith;
        }
        i++;
    }

}

org.apache.commons.lang.StringUtils # chopNewline

Versuchen Sie Folgendes:

 textValue= textValue.replaceAll("\n", "");
 textValue= textValue.replaceAll("\t", "");
 textValue= textValue.replaceAll("\\n", "");
 textValue= textValue.replaceAll("\\t", "");
 textValue= textValue.replaceAll("\r", "");
 textValue= textValue.replaceAll("\\r", "");
 textValue= textValue.replaceAll("\r\n", "");
 textValue= textValue.replaceAll("\\r\\n", "");