Split Java String par New Line

J'essaie de diviser le texte en JTextAreautilisant une expression régulière pour diviser la chaîne par \nCependant, cela ne fonctionne pas et j'ai également essayé par \r\n|\r|net de nombreuses autres combinaisons d'expressions régulières. Code:

public void insertUpdate(DocumentEvent e) {
    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");
}

Cela devrait vous couvrir:

String lines[] = string.split("\\r?\\n");

Il n'y a vraiment que deux nouvelles lignes (UNIX et Windows) dont vous devez vous soucier.

String#split​(String regex)utilise regex (expressions régulières). Depuis Java 8 regex prend en charge \Rqui représente (à partir de la documentation de la classe Pattern ):

Correspondance de saut de ligne
\ R Toute séquence de saut de ligne Unicode est équivalente à \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

Nous pouvons donc l'utiliser pour faire correspondre:

• \u000D\000A-> \r\npaire
• \ u000A -> saut de ligne ( \n)
• \ u000B -> tabulation de ligne (NE PAS confondre avec la tabulation de caractères \tqui est\u0009 )
• \ u000C -> flux de formulaire ( \f)
• \ u000D -> retour chariot ( \r)
• \ u0085 -> ligne suivante (NEL)
• \ u2028 -> séparateur de ligne
• \ u2029 -> séparateur de paragraphe

Comme vous le voyez, il \r\nest placé au début de l'expression régulière, ce qui garantit que l'expression régulière tentera de faire correspondre cette paire en premier, et seulement si cette correspondance échoue, elle essaiera de faire correspondre les séparateurs de ligne à caractère unique .

Donc, si vous voulez diviser l'utilisation du séparateur de ligne split("\\R").

Si vous ne souhaitez pas supprimer du tableau résultant les chaînes vides de fin,"" utilisez-les split(regex, limit)avec un limitparamètre négatif comme split("\\R", -1).

Si vous souhaitez traiter une ou plusieurs lignes vides continues comme un seul délimiteur split("\\R+").

Si vous ne voulez pas de lignes vides:

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

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

Cela devrait être indépendant du système

Une nouvelle méthode linesa été introduite en Stringclasse dansjava-11, qui renvoie Stream<String>

Renvoie un flux de sous-chaînes extraites de cette chaîne partitionnée par des terminateurs de ligne.

Les terminateurs de ligne reconnus sont le saut de ligne "\ n" (U + 000A), le retour chariot "\ r" (U + 000D) et un retour chariot suivi immédiatement d'un saut de ligne "\ 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

Chaîne # lignes ()

Vous n'avez pas à doubler les caractères d'échappement dans les groupes de caractères.

Pour toutes les lignes non vides, utilisez:

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

Dans JDK11la Stringclasse a une lines()méthode:

Renvoyer un flux de lignes extraites de cette chaîne, séparées par des terminateurs de ligne.

De plus, la documentation poursuit en disant:

Un terminateur de ligne est l'un des éléments suivants: un caractère de saut de ligne "\ n" (U + 000A), un caractère de retour chariot "\ r" (U + 000D) ou un retour chariot suivi immédiatement d'un saut de ligne "\ r \ n "(U + 000D U + 000A). Une ligne est soit une séquence de zéro ou plusieurs caractères suivis d'un terminateur de ligne, soit une séquence d'un ou plusieurs caractères suivie de la fin de la chaîne. Une ligne n'inclut pas le terminateur de ligne.

Avec cela, on peut simplement faire:

Stream<String> stream = str.lines();

alors si vous voulez un tableau:

String[] array = str.lines().toArray(String[]::new);

Étant donné que cette méthode renvoie un flux, elle propose de nombreuses options pour vous, car elle permet d'écrire une expression concise et déclarative d'opérations éventuellement parallèles.

Peut-être que cela fonctionnerait:

Supprimez les doubles barres obliques inverses du paramètre de la méthode de fractionnement:

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

Toutes les réponses données ici ne respectent en fait pas la définition Javas des nouvelles lignes comme donnée par exemple dans BufferedReader # readline. Java accepte \n, \ret \r\ncomme nouvelle ligne. Certaines réponses correspondent à plusieurs lignes vides ou à des fichiers mal formés. Par exemple. <sometext>\n\r\n<someothertext>lors de l'utilisation [\r\n]+entraînerait 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 est conforme à la définition Javas d'une nouvelle ligne comme par exemple le BufferedReader l'utilise
• il ne correspond pas à plusieurs nouvelles lignes
• il ne supprime pas les lignes vides de fin

Si, pour une raison quelconque, vous ne souhaitez pas utiliser String.split(par exemple, en raison d' expressions régulières ) et que vous souhaitez utiliser la programmation fonctionnelle sur Java 8 ou une version plus récente:

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

Pour éviter que les lignes vides ne soient écrasées, utilisez:

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

Le code ci-dessus ne fait en fait rien de visible - il calcule simplement puis décharge le calcul. Est-ce le code que vous avez utilisé, ou juste un exemple pour cette question?

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

Comme alternative aux réponses précédentes, l' SplitterAPI de goyave peut être utilisée si d'autres opérations doivent être appliquées aux lignes résultantes, comme le découpage des lignes ou le filtrage des 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 Iterableet non un tableau.

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

Après des tentatives infructueuses sur la base de toutes les solutions données. Je remplace \npar un mot spécial puis je me sépare. Pour moi, la suite a fait l'affaire:

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

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

Les réponses ci-dessus ne m'ont pas aidé sur Android, grâce à la réponse Pshemo qui a fonctionné pour moi sur Android. Je vais laisser une partie de la réponse de Pshemo ici:

split("\\\\n")

• essayez cet espoir, 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 que ce sont 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 contre l'autre:

La chose la plus simple est de normaliser line feedpuis de diviser.

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

Il y a un nouveau garçon dans la ville, vous n'avez donc pas besoin de faire face à toutes les complexités ci-dessus. À partir de JDK 11 , il suffit d'écrire en une seule ligne de code, il divisera les lignes et vous renverra un flux de chaîne.

public class MyClass {
public static void main(String args[]) {
   Stream<String> lines="foo \n bar \n baz".lines();
   //Do whatever you want to do with lines
}}

Quelques références. https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#lines () https://www.azul.com/90-new -features-and-apis-in-jdk-11 /

J'espère que cela sera utile à quelqu'un. Codage heureux.

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

}