Split Java String par nouvelle ligne

si vous ne voulez pas de lignes vides:

String.split("[\r\n]+")

split méthode utilisant regex (expressions régulières). Depuis Java 8 regex prend en charge \R qui représente (de la documentation de la classe de modèle ):

saut de ligne matcher

\R toute séquence de linebreak Unicode, est équivalente à \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

donc nous pouvons l'utiliser pour correspondre:

• \u000D"151930920"0A -> \r\n paire
• \u000A -> saut de ligne ( \n )
• \u000B - > tabulation des lignes (ne pas confondre avec tabulation des caractères \t qui est \u0009 1519190920")
• \u000C -> saut de page ( \f )
• \u000D - > retour chariot ( \r )
• \u0085 - > ligne suivante (NEL)
• \u2028 - > séparateur de ligne
• \u2029 - > séparateur de paragraphe

comme vous le voyez \r\n est placé au début de regex qui assure que regex va essayer de faire correspondre d'abord cette" paire 1519660920 , et seulement si elle échoue, il essaiera caractère unique ligne de séparation.

donc si vous voulez diviser sur le séparateur de ligne utiliser split("\R") .

si vous ne voulez pas supprimer du tableau résultant les chaînes vides "" utilisez split(regex, limit) avec négatif limit paramètre comme split("\R", -1) .

si vous voulez traiter une ou plusieurs lignes vides en tant que délimiteur unique, utilisez split("\R+") .

String.split(System.getProperty("line.separator"));

cela devrait être indépendant du système

vous n'avez pas à double caractères escape dans les groupes de caractères.

pour toutes les lignes non vides utiliser:

String.split("[\r\n]+")

peut-être que ça marcherait:

supprimer les doubles barres obliques du paramètre de la méthode split:

split = docStr.split("\n");

pour préserver les lignes vides de se faire écraser utiliser:

String lines[] = String.split("\r?\n", -1);

toutes les réponses données ici ne respectent pas la définition Javas des nouvelles lignes comme indiqué dans Par exemple BufferedReader#readline. Java accepte \n , \r et \r\n comme nouvelle ligne. Certaines réponses correspondent à plusieurs lignes vides ou à des fichiers mal formés. E..G. <sometext>\n\r\n<someothertext> en utilisant [\r\n]+ donnerait deux lignes.

String lines[] = string.split("(\r\n|\r|\n)", -1);

En revanche, la réponse ci-dessus a les propriétés suivantes:

• il conforme à la définition Javas d'une nouvelle ligne telle que par exemple le BufferedReader l'utilise
• il ne correspond pas à des nouvelles lignes multiples
• il ne supprime pas les lignes vides traînantes

le code ci - dessus ne fait pas réellement quelque chose de visible-il calcualtes vient alors dumps le calcul. C'est le code que vous avez utilisé, ou juste un exemple pour cette question?

essayez le textAreaDoc.insertString (int, String, AttributeSet) à la fin?

renvoie un flux de substrats extraits de cette chaîne en ligne terminateurs.

les terminateurs de ligne reconnus sont des lignes d'alimentation "\n " (U+000A), chariot retour "\R " (U+000D) et retour de chariot suivi immédiatement d'un retour ligne d'alimentation "\r\n " (U+000D U+000A).

Voici quelques exemples:

jshell> "lorem \n ipusm \n sit".lines().forEach(System.out::println)
lorem
 ipusm
 sit

jshell> "lorem \n ipusm \r  sit".lines().forEach(System.out::println)
lorem
 ipusm
  sit

jshell> "lorem \n ipusm \r\n  sit".lines().forEach(System.out::println)
lorem
 ipusm
  sit

String#lines ()

si, pour une raison quelconque, vous ne voulez pas utiliser String.split (par exemple, à cause de expressions régulières ) et vous voulez utiliser la programmation fonctionnelle sur Java 8 ou plus récent:

List<String> lines = new BufferedReader(new StringReader(string))
        .lines()
        .collect(Collectors.toList());

String lines[] =String.split( System.lineSeparator())

après des tentatives infructueuses sur la base de toutes les solutions données. Je remplace \n par un mot spécial et je divise. Pour moi le suivant a fait le tour:

article = "Alice phoned\n bob.";
article = article.replace("\n", " NEWLINE ");
String sen [] = article.split(" NEWLINE ");

Je n'ai pas pu répliquer l'exemple donné dans la question. Mais, je suppose que cette logique peut être appliquée.

comme alternative aux réponses précédentes, l'API Splitter de guava peut être utilisée si d'autres opérations doivent être appliquées aux lignes résultantes, comme couper les lignes ou filtrer les lignes vides:

import com.google.common.base.Splitter;

Iterable<String> split = Splitter.onPattern("\r?\n").trimResults().omitEmptyStrings().split(docStr);

Notez que le résultat est un Iterable et pas un tableau.

• essayez cet espoir qu'il vous a été utile

 String split[], docStr = null;
Document textAreaDoc = (Document)e.getDocument();

try {
    docStr = textAreaDoc.getText(textAreaDoc.getStartPosition().getOffset(), textAreaDoc.getEndPosition().getOffset());
} catch (BadLocationException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
}

split = docStr.split("\n");

il existe trois conventions différentes (on pourrait dire qu'il s'agit des normes de facto ) pour définir et afficher un saut de ligne:

• carriage return + line feed
• line feed
• carriage return

Dans certains éditeurs de texte, il est possible d'échanger l'un pour l'autre:

la chose la plus simple est de normaliser en line feed et puis de diviser.

final String[] lines = contents.replace("\r\n", "\n")
                               .replace("\r", "\n")
                               .split("\n", -1);

package in.javadomain;

public class JavaSplit {

    public static void main(String[] args) {
        String input = "chennai\nvellore\ncoimbatore\nbangalore\narcot";
        System.out.println("Before split:\n");
        System.out.println(input);

        String[] inputSplitNewLine = input.split("\n");
        System.out.println("\n After split:\n");
        for(int i=0; i<inputSplitNewLine.length; i++){
            System.out.println(inputSplitNewLine[i]);
        }
    }

}