web-dev-qa-db-fra.com

Supprimer toutes les lignes vides

Je pensais que ce n'était pas si difficile à faire, mais je veux supprimer toutes les lignes vides (ou les lignes ne contenant que des blancs et des tabulations en Java) avec String.replaceAll.

Mon regex ressemble à ceci:

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

Mais ça ne marche pas.

J'ai regardé autour de moi, mais je n'ai trouvé que des expressions rationnelles pour supprimer des lignes vides sans espaces ni tabulations.

javaregexstring
28
reox

Essaye ça:

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

Notez que la regex [ |\t] correspond à un espace, une tabulation ou un caractère de pipe!

MODIFIER

B.t.w., le regex (?m)^\s+$ ferait également l'affaire.

71
Bart Kiers

Je ne connais pas la syntaxe des expressions régulières en Java, mais /^\s*$[\n\r]{1,}/gm est l'expression régulière que vous recherchez.

Vous l'écrivez probablement comme ceci en Java:

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

Je l'ai testé avec JavaScript et cela fonctionne bien.

4
Alin Purcaru

Je ne suis pas un programmeur Java quotidien, je suis donc surpris qu'il n'y ait pas de moyen plus simple de faire cela dans le JDK qu'avec une expression régulière.

En tous cas,

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

serait un peu plus simple.

Mettre à jour:

Désolé, j'ai regretté de ne pas avoir voulu supprimer des espaces et des tabulations.

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

Cela fonctionnerait si vous avez des nouvelles lignes cohérentes. Sinon, vous pouvez envisager de les rendre cohérentes. Par exemple.:

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

Vous pouvez supprimer les lignes vides de votre code à l'aide du code suivant:

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

Ici, plainTextWithEmptyLines indique la chaîne ayant les lignes vides. [\\\r\\\n] est le modèle regex utilisé pour identifier les sauts de ligne vides.

3
Manvendra_0611

Si vous souhaitez supprimer les lignes de Microsoft Office, Windows ou d'un éditeur de texte prenant en charge le rendu des expressions régulières:

 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.

Vous verrez tous vos espaces noirs dans votre éditeur disparaître ...

1
nitesh

J'ai du code sans utiliser regexp, il suffit d'importer 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

Réponse de Bart Kiers manque le cas Edge où la dernière ligne de la chaîne est vide ou contient des espaces.

Si tu essayes

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

vous obtiendrez une chaîne égale à cette

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

à la suite.

J'ai développé Bart Kiers 'réponse pour couvrir également ce cas.

Mon motif de regex est:

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

Une petite explication:

La première partie du motif est fondamentalement la même que Bart Kiers '. C'est bien, mais cela ne supprime pas une dernière ligne "vide" ou une dernière ligne contenant des espaces.

En effet, une dernière ligne contenant uniquement des espaces ne se termine pas par \\r?\\n et ne serait donc pas mise en correspondance/remplacée. Nous avons besoin de quelque chose pour exprimer ce cas Edge. C'est là qu'intervient la deuxième partie (après le |).

Il utilise une spécialité d'expression régulière: look look négatif. C'est la partie (?!.*\\r?\\n) du motif. (?! marque le début de la recherche anticipée. Vous pouvez le lire comme suit: Faites correspondre l'expression régulière avant le préfixe si elle n'est pas suivie de tout ce qui est défini comme une chaîne qui ne doit pas suivre. Dans notre cas: pas de caractère (zéro ou plus de fois) suivi d'un retour de chariot (0 ou 1 fois) et d'une nouvelle ligne: .*\\r?\\n. Le ) ferme le lookahead. Le lookahead lui-même ne fait pas partie du match.

Si j'exécute le fragment de code suivant:

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

Je reçois:

 inputString: 
 + ----

 Ligne 2 - la ligne ci-dessus est vide, sans espaces 
 Ligne 3 - suivante est vide sans les espaces 

 Ligne 5 - ligne suivante est avec des espaces 

 Ligne 7 - les deux lignes suivantes sont "vides". Le premier avec des espaces blancs .


 Ligne 10 - 3 lignes vides suivent. Le 2ème avec des espaces blancs dedans. Un espace à la fin de cette ligne 



---- + 
 AjdustedString: 
 + ----
 Ligne 2 - la ligne ci-dessus est vide, sans espace 
 La ligne 3 - est vide sans espaces blancs 
 Ligne 5 - la ligne suivante est avec espaces blancs 
 Ligne 7 - les deux lignes suivantes sont "vides". Le premier avec des espaces blancs ..
 Ligne 10 - Trois lignes vides suivent. Le 2ème avec des espaces blancs dedans. Un espace à la fin de cette ligne | EOS 
---- +

Si vous voulez en savoir plus sur lookahead/lookbehind voir Tutoriel Regex - Lookahead et Lookbehind Zero-Length Assertions:

0
kriddoff