Comment supprimer les sauts de ligne d'un fichier en Java?

Comment puis-je remplacer tous les sauts de ligne d'une chaîne en Java d'une manière qui fonctionnera sur Windows et Linux (c'est-à-dire pas de problèmes spécifiques au système d'exploitation de retour chariot / saut de ligne / nouvelle ligne, etc.)?

J'ai essayé (notez que readFileAsString est une fonction qui lit un fichier texte dans une chaîne):

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

mais cela ne semble pas fonctionner.

Comment cela peut-il être fait?

Vous devez définir textles résultats de text.replace():

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

Cela est nécessaire car les chaînes sont immuables - l'appel replacene change pas la chaîne d'origine, il renvoie une nouvelle qui a été modifiée. Si vous n'affectez pas le résultat à text, cette nouvelle chaîne est perdue et récupérée.

Quant à obtenir la chaîne de nouvelle ligne pour n'importe quel environnement - qui est disponible en appelant System.getProperty("line.separator").

Comme indiqué dans d'autres réponses, votre code ne fonctionne pas principalement parce String.replace(...)qu'il ne modifie pas la cible String. (Il ne peut pas - les chaînes Java sont immuables!) Ce replacequi fait réellement est de créer et de renvoyer un nouvel Stringobjet avec les caractères modifiés selon les besoins. Mais votre code jette alorsString ...

Voici quelques solutions possibles. Laquelle est la plus correcte dépend de ce que vous essayez de faire exactement.

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

Supprime simplement tous les caractères de nouvelle ligne. Cela ne résiste pas aux terminaisons de ligne Windows ou Mac.

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

Supprime tous les terminateurs de ligne pour la plate-forme actuelle. Cela ne résout pas le cas où vous essayez de traiter (par exemple) un fichier UNIX sous Windows, ou vice versa.

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

Supprime tous les terminateurs de ligne Windows, UNIX ou Mac. Cependant, si le fichier d'entrée est du texte, cela concaténera les mots; par exemple

Goodbye cruel
world.

devient

Goodbye cruelworld.

Donc, vous voudrez peut-être faire ceci:

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

qui remplace chaque terminaison de ligne par un espace. Depuis Java 8, vous pouvez également faire ceci:

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

Et si vous souhaitez remplacer plusieurs séparateurs de lignes par un espace:

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

Si vous souhaitez supprimer uniquement les terminateurs de ligne valides sur le système d'exploitation actuel, vous pouvez procéder comme suit:

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

Si vous voulez vous assurer de supprimer tous les séparateurs de ligne, vous pouvez le faire comme ceci:

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

Ou, un peu plus verbeux, mais moins regexy:

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

Cette fonction normalise tous les espaces, y compris les sauts de ligne, en espaces simples. Pas exactement ce que la question initiale demandait, mais susceptible de faire exactement ce qui est nécessaire dans de nombreux cas:

import org.apache.commons.lang3.StringUtils;

final String cleansedString = StringUtils.normalizeSpace(rawString);

Ce serait efficace je suppose

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

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

A parfaitement fonctionné pour moi après avoir beaucoup cherché, ayant échoué avec toutes les autres lignes.

Les sauts de ligne ne sont pas les mêmes sous windows / linux / mac. Vous devez utiliser System.getProperties avec l'attribut line.separator.

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

.replace renvoie une nouvelle chaîne, les chaînes en Java sont immuables.

Vous voudrez peut-être lire votre fichier avec un BufferedReader. Cette classe peut diviser l'entrée en lignes individuelles, que vous pouvez assembler à volonté. Le cheminBufferedReader fonctionnement reconnaît automatiquement les conventions de fin de ligne des mondes Linux, Windows et MacOS, quelle que soit la plate-forme actuelle.

Par conséquent:

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

Notez que readLine()n'inclut pas le terminateur de ligne dans la chaîne renvoyée. Le code ci-dessus ajoute un espace pour éviter de coller ensemble le dernier mot d'une ligne et le premier mot de la ligne suivante.

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

Même si la définition de trim () dans le site Web Oracle est "Renvoie une copie de la chaîne, avec les espaces de début et de fin omis".

la documentation omet de dire que les nouveaux caractères de ligne (début et fin) seront également supprimés.

En bref, String text = readFileAsString("textfile.txt").trim();cela fonctionnera également pour vous. (Vérifié avec Java 6)

Je trouve étrange que (Apache) StringUtils ne soit pas encore couvert ici.

vous pouvez supprimer tous les sauts de ligne (ou toute autre occurrence d'une sous-chaîne d'ailleurs) d'une chaîne en utilisant la .replaceméthode

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

Cette ligne remplacera toutes les nouvelles lignes par la chaîne vide.

parce que la nouvelle ligne est techniquement un caractère, vous pouvez éventuellement utiliser la .replaceCharsméthode qui remplacera les caractères

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

Pour info si vous pouvez remplacer les sauts de ligne simultanés par des sauts de ligne simples, vous pouvez utiliser

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

Ou remplacez par un seul espace

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

Vous pouvez utiliser des IOUtils apache commons pour parcourir la ligne et ajouter chaque ligne à StringBuilder. Et n'oubliez pas de fermer 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);

Vous pouvez utiliser des méthodes génériques pour remplacer n'importe quel caractère par n'importe quel caractère.

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

Essayez de faire ceci:

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