Comment faire pour supprimer les sauts de ligne à partir d'un fichier en Java?

Comment puis-je le remplacer tous les sauts de ligne à partir d'une chaîne de caractères en Java dans une telle manière qui fonctionne sur Windows et Linux (c'est à dire pas OS des problèmes spécifiques de retour chariot/saut de ligne/ligne nouvelle, etc.)?

J'ai essayé (note readFileAsString est une fonction qui lit un fichier texte dans une Chaîne de caractères):

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

mais cela ne semble pas fonctionner.

Comment cela peut-il être fait?

Vous voulez éliminer tous les sauts de ligne? Ou vous souhaitez uniformiser à une solution standard?
Oh, si vous souhaitez supprimer tous les sauts de ligne, supprimer tous les \n ET tous les \r (car Windows saut de ligne est \r\n).
Hey, pour info si vous voulez remplacer simultanée muti-retours à la ligne (avec un seul saut de ligne, alors vous pouvez utiliser myString.trim().replaceAll("[\n]{2,}", "\n") Ou remplacez-les par un espace unique myString.trim().replaceAll("[\n]{2,}", " ")

InformationsquelleAutor tree-hacker | 2010-01-29

388

Vous devez définir text aux résultats de text.replace():
```
String text = readFileAsString("textfile.txt");
text = text.replace("\n", "").replace("\r", "");
```
Cela est nécessaire parce que les Chaînes sont immuables-appel replace ne pas changer de Chaîne, elle renvoie un nouveau qui a été modifié. Si vous n'affectez pas le résultat de text, alors que la nouvelle Chaîne est perdu et les ordures collectées.

Comme pour obtenir le retour à la ligne de Chaîne à n'importe quel environnement -- qui est disponible en appelant System.getProperty("line.separator").
- +1, c'est exact. Quant à la raison: la Chaîne est immuable. Le replace() méthode renvoie le résultat souhaité. Voir aussi l'API docs: java.sun.com/javase/6/docs/api/java/lang/... Edit: ah vous avez déjà édité que vous-même dans la suite 🙂
- Peut-être text = text.replace("\r\n", " ").replace("\n", " "); est une meilleure solution: autrement mots seront "collés" les uns aux autres (sans le seul espace de remplacement).
- Oui, c'est possible. Tout dépend de quel type de données que vous êtes en train de la modifier. Parfois, pour des données telles que COBOL cahiers) vous ne voulez pas qu'il y a des espaces entre les lignes.
- Vrai, tout dépend de ce que l'OP est en train de faire.
- Vous pouvez également utiliser des crochets pour correspondre à des retours à la ligne correctement pour n'importe quel système d'exploitation: .replaceAll("[\\r\\n]+", "")
- Comme la question est de demander le remplacement de TOUTES les occurrences, la solution est plutôt text = text.replaceAll("\n", "").replaceAll("\r", "");
- prend en regex, replace prend dans les chaînes littérales, à la fois de remplacer toutes les occurences.
- attention la création d'un Système de dépendance, il peut-être ce que vous voulez, mais j'ai eu un test unitaire avec une Chaîne statique qui est passé sur Windows local de la machine, mais à défaut sur la version d'Intégration Continue de la machine (Linux)
InformationsquelleAutor Kaleb Brasee
199

Comme indiqué dans d'autres réponses, votre code ne fonctionne pas principalement parce que String.replace(...) ne modifie pas la Chaîne cible. (Il ne peut pas - Java, les chaînes sont immuables!) Ce qu'il fait n'est crée une nouvelle Chaîne avec les caractères modifiés. Mais votre code puis jette cette Chaîne ...

Voici quelques solutions possibles. Celui qui est le plus correct dépend exactement ce que vous essayez de faire.
```
//#1
text = text.replace("\n", "");
```
Simplement supprime tous les caractères de saut de ligne. Ce n'est pas faire face avec Windows ou Mac les fins de ligne.
```
//#2
text = text.replace(System.getProperty("line.separator"), "");
```
Supprime tous les terminateurs de ligne pour la plate-forme actuelle. Ce n'est pas de gérer le cas où vous essayez de processus (par exemple) un fichier UNIX sur Windows, ou vice versa.
```
//#3
text = text.replaceAll("\\r|\\n", "");
```
Supprime tous les Windows, UNIX ou Mac ligne terminateurs. Toutefois, si le fichier d'entrée est du texte, ce concaténer des mots; par exemple,
```
Goodbye cruel
world.
```
devient
```
Goodbye cruelworld.
```
De sorte que vous pourriez réellement envie de le faire:
```
//#4
text = text.replaceAll("\\r\\n|\\r|\\n", " ");
```
qui remplace chaque terminaison de ligne avec un espace. Depuis Java 8, vous pouvez également le faire:
```
//#5
text = text.replaceAll("\\R", " ");
```
Et si vous souhaitez remplacer plusieurs séparateurs de ligne avec un espace:
```
//#6
text = text.replaceAll("\\R+", " ");
```
InformationsquelleAutor Stephen C
19

Si vous souhaitez supprimer la ligne des terminaisons qui sont valables sur le système d'exploitation actuel, vous pourriez faire ceci:
```
text = text.replaceAll(System.getProperty("line.separator"), "");
```
Si vous voulez assurez-vous 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", "");
```
- Pour éviter le collage de mot (comme discuté dans les commentaires de Kaleb de réponse) les regex approche pourrait être modifié pour text.replaceAll("(\\r|\\n)+", " ") et (en supposant que gourmand est par défaut en Java?) vous aurez une solution avec juste un de l'espace pour chaque séquence de la nouvelle ligne de caractères.
InformationsquelleAutor Fabian Steeg
11

Cette fonction normalise vers le bas tous les espaces, y compris les sauts de ligne, à des espaces simples. Pas exactement ce que l'original question posée, mais susceptibles de faire exactement ce qui est nécessaire dans de nombreux cas:
```
import org.apache.commons.lang3.StringUtils;

final String cleansedString = StringUtils.normalizeSpace(rawString);
```
InformationsquelleAutor David McWhorter
10
```
str = str.replaceAll("\\r\\n|\\r|\\n", " ");
```
A parfaitement fonctionné pour moi, après la recherche d'un lot, après avoir échoué avec chaque autre ligne.

InformationsquelleAutor Renán D
9

Ce serait efficace je suppose que
```
String s;
s = "try this\n try me.";
s.replaceAll("[\\r\\n]+", "")
```
édité pour la surbrillance de la syntaxe
- ne fonctionne pas pour moi..
InformationsquelleAutor JSBach
6

Mais les sauts de ligne ne sont pas de la même sous windows/linux/mac. Vous devez utiliser Système.getProperties avec l'attribut de la ligne.séparateur.

InformationsquelleAutor Aif
3
```
String text = readFileAsString("textfile.txt").replace("\n","");
```
.remplacer renvoie une nouvelle chaîne de caractères, chaînes de caractères en Java sont Immuables.

InformationsquelleAutor Viktor Klang
3

Vous voudrez peut-être lire votre fichier avec un BufferedReader. Cette classe peut casser d'entrée en lignes individuelles, que vous pouvez assembler à volonté. La façon BufferedReader fonctionne reconnaît de fin de ligne conventions de l'Linux, Windows et MacOS mondes automatiquement, indépendamment de la plate-forme actuelle.

Donc:
```
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();
```
Noter que readLine() ne comprend 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.

InformationsquelleAutor Thomas Pornin
3
```
String text = readFileAsString("textfile.txt").replaceAll("\n", "");
```
Même si la définition de trim() dans oracle site web est
"Retourne une copie de la chaîne, avec attaque et de fuite des espaces omis."

la documentation omet de dire que les caractères de nouvelle ligne (avant et arrière) seront également supprimées.

En bref
String text = readFileAsString("textfile.txt").trim(); aussi le travail pour vous.
(Vérifié avec Java 6)

InformationsquelleAutor MukeshKoshyM
1

Je trouve bizarre que (Apache) StringUtils n'était pas couvert ici encore.

vous pouvez supprimer tous les retours à la ligne (ou toutes les autres occurrences d'une sous-chaîne que ce soit), à partir d'une chaîne à l'aide de la .replace méthode
```
StringUtils.replace(myString, "\n", "");
```
Cette ligne permettra de remplacer tous les retours à la ligne avec la chaîne vide.

parce que le saut de ligne est techniquement un personnage que vous pouvez éventuellement utiliser l' .replaceChars méthode de remplacement de caractères
```
StringUtils.replaceChars(myString, '\n', '');
```
- StringUtils.replaceEachRepeatedly(myString, new String[]{"\n", "\t"}, new String[]{StringUtils.Empty, StringUtils.Empty});
InformationsquelleAutor svarog
0

Pour info si vous voulez remplacer simultanée muti-retours à la ligne (avec un seul saut de ligne, alors vous pouvez utiliser
```
myString.trim().replaceAll("[\n]{2,}", "\n")
```
Ou remplacez-les par un espace unique
```
myString.trim().replaceAll("[\n]{2,}", " ")
```
InformationsquelleAutor Sourav Chandra

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

InformationsquelleAutor Shravan Ramamurthy

Vous pouvez utiliser des méthodes génériques pour remplacer tout char avec n'importe quel char.

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

}

InformationsquelleAutor Rakesh Chaudhari

-1

org.apache.commons.lang.StringUtils#chopNewline
- -1 parce que Deprecated et supprime uniquement à la fin de la chaîne.
InformationsquelleAutor Kumar Abhishek

-2

Essayez de faire cela:

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

si vous remplacez \n il n'y a pas de \r\n plus si vous remplacez \n et il y a un \\n, elle sera remplacée pour seulement l' \ restera.

InformationsquelleAutor seyf

Vous devez vous connecter pour publier un commentaire.