Come rimuovere le interruzioni di riga da un file in Java?

Come posso sostituire tutte le interruzioni di riga da una stringa in Java in modo tale che funzionino su Windows e Linux (cioè nessun problema specifico del sistema operativo di ritorno a capo / avanzamento riga / nuova riga ecc.)?

Ho provato (nota readFileAsString è una funzione che legge un file di testo in una stringa):

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

ma questo non sembra funzionare.

Come si può fare?

È necessario impostare texti risultati di text.replace():

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

Ciò è necessario perché le stringhe sono immutabili: la chiamata replacenon modifica la stringa originale, ma ne restituisce una nuova che è stata modificata. Se non si assegna il risultato a text, la nuova stringa viene persa e la garbage collection.

Per quanto riguarda ottenere la stringa newline per qualsiasi ambiente, che è disponibile chiamando System.getProperty("line.separator").

Come notato in altre risposte, il codice non funziona principalmente perché String.replace(...)non cambia la destinazione String. (Non può - le stringhe Java sono immutabili!) Ciò che replaceeffettivamente fa è creare e restituire un nuovo Stringoggetto con i caratteri modificati come richiesto. Ma il tuo codice quindi butta via quel String...

Ecco alcune possibili soluzioni. Qual è il più corretto dipende da cosa stai esattamente cercando di fare.

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

Rimuove semplicemente tutti i caratteri di nuova riga. Questo non fa fronte alle terminazioni di linea di Windows o Mac.

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

Rimuove tutti i terminatori di linea per la piattaforma corrente. Ciò non risolve il caso in cui si sta tentando di elaborare (ad esempio) un file UNIX su Windows o viceversa.

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

Rimuove tutti i terminatori di linea Windows, UNIX o Mac. Tuttavia, se il file di input è testo, questo concatena le parole; per esempio

Goodbye cruel
world.

diventa

Goodbye cruelworld.

Quindi potresti effettivamente voler fare questo:

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

che sostituisce ogni terminatore di riga con uno spazio. Da Java 8 puoi anche fare questo:

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

E se vuoi sostituire più separatori di riga con uno spazio:

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

Se si desidera rimuovere solo i terminatori di linea validi sul sistema operativo corrente, è possibile effettuare ciò:

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

Se vuoi assicurarti di rimuovere eventuali separatori di riga, puoi farlo in questo modo:

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

O, leggermente più prolisso, ma meno regexy:

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

Questa funzione consente di normalizzare tutti gli spazi bianchi, comprese le interruzioni di riga, in singoli spazi. Non esattamente ciò che la domanda originale ha richiesto, ma probabilmente farà esattamente ciò che è necessario in molti casi:

import org.apache.commons.lang3.StringUtils;

final String cleansedString = StringUtils.normalizeSpace(rawString);

Questo sarebbe efficace immagino

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

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

Ha funzionato perfettamente per me dopo aver cercato molto, avendo fallito con ogni altra linea.

Le interruzioni di riga non sono le stesse in Windows / Linux / Mac. È necessario utilizzare System.getProperties con l'attributo line.separator.

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

.replace restituisce una nuova stringa, le stringhe in Java sono immutabili.

Potresti voler leggere il tuo file con a BufferedReader. Questa classe può suddividere l'input in singole righe, che puoi assemblare a piacimento. La viaBufferedReader opera riconosce automaticamente le convenzioni di fine linea dei mondi Linux, Windows e MacOS, indipendentemente dalla piattaforma attuale.

Quindi:

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();

Si noti che readLine()non include il terminatore di riga nella stringa restituita. Il codice sopra aggiunge uno spazio per evitare di incollare insieme l'ultima parola di una riga e la prima parola della riga successiva.

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

Anche se la definizione di trim () nel sito Web Oracle è "Restituisce una copia della stringa, con spazi bianchi iniziali e finali omessi".

la documentazione omette di dire che verranno rimossi anche i nuovi caratteri di linea (in testa e in coda).

In breve String text = readFileAsString("textfile.txt").trim();funzionerà anche per te. (Controllato con Java 6)

Trovo strano che (Apache) StringUtils non sia ancora stato trattato qui.

puoi rimuovere tutte le newline (o qualsiasi altra occorrenza di una sottostringa per quella materia) da una stringa usando il .replacemetodo

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

Questa riga sostituirà tutte le nuove righe con la stringa vuota.

poiché newline è tecnicamente un personaggio, puoi facoltativamente usare il .replaceCharsmetodo che sostituirà i caratteri

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

Cordiali saluti, se si desidera sostituire simultaneamente interruzioni di riga con interruzioni di riga singola, è possibile utilizzare

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

Oppure sostituisci con un unico spazio

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

Puoi usare IOUtils comuni di apache per scorrere la riga e aggiungere ogni riga a StringBuilder. E non dimenticare di chiudere InputStream

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

È possibile utilizzare metodi generici per sostituire qualsiasi carattere con qualsiasi carattere.

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

Prova a fare questo:

 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", "");