Split Java String by New Line

Questo dovrebbe coprirti:

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

Ci sono solo due newline (UNIX e Windows) di cui devi preoccuparti.

Se non vuoi linee vuote:

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

split metodo split usa la regex (espressioni regolari). Poiché la regex di Java 8 supporta \R che rappresenta (dalla documentazione della class Pattern ):

Matcher Linebreak
\ R Qualsiasi sequenza di interruzione di \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029] Unicode è equivalente a \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

Quindi possiamo usarlo per abbinare:

• \u000D\000A -> \r\n coppia
• \ u000A -> avanzamento riga ( \n )
• \ u000B -> tabulazione delle linee (NON confondere con la tabulazione dei caratteri \t che è \u0009 )
• \ u000C -> modulo feed ( \f )
• \ u000D -> ritorno a capo ( \r )
• \ u0085 -> riga successiva (NEL)
• \ u2028 -> separatore di riga
• \ u2029 -> separatore di paragrafi

Come vedi \r\n è posto all’inizio della regex che assicura che la regex proverà ad abbinare prima questa coppia , e solo se fallisce cercherà di abbinare i separatori di riga di un singolo carattere .

Quindi se vuoi dividere il separatore di riga usa split("\\R") .

Se non si desidera rimuovere dall’array risultante le stringhe vuote finali "" usano split(regex, limit) con il parametro limit negativo come split("\\R", -1) .

Se si desidera trattare una o più righe continue continue come delimitatore singolo usare split("\\R+") .

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

Questo dovrebbe essere indipendente dal sistema

Non è necessario raddoppiare i caratteri di escape nei gruppi di caratteri.

Per tutte le linee non vuote utilizzare:

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

Forse questo avrebbe funzionato:

Rimuovi i doppi backslash dal parametro del metodo split:

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

Per preservare le linee vuote dall’uso schiacciato:

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

Tutte le risposte date qui in realtà non rispettano la definizione di Javas di nuove righe, come indicato ad esempio in # reader di BufferedReader. Java accetta \n , \r e \r\n come nuova riga. Alcune risposte corrispondono a più righe vuote o file non validi. Per esempio. \n\r\n se si utilizza [\r\n]+ risulterebbe in due righe.

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

Al contrario, la risposta sopra ha le seguenti proprietà:

• è conforms alla definizione Javas di una nuova riga come ad esempio BufferedReader lo sta usando
• non corrisponde a più nuove linee
• non rimuove le righe vuote finali

Il codice sopra non fa in realtà nulla di visibile – fa solo calcoli e poi scarica il calcolo. È il codice che hai usato, o solo un esempio per questa domanda?

prova a fare textAreaDoc.insertString (int, String, AttributeSet) alla fine?

Se, per qualche motivo, non si desidera utilizzare String.split (ad esempio, a causa delle espressioni regolari ) e si desidera utilizzare la programmazione funzionale su Java 8 o versioni successive:

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

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

Dopo tentativi falliti sulla base di tutte le soluzioni fornite. Sostituisco \n con alcune parole speciali e poi lo divido. Per me seguire il trucco:

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

Non potrei replicare l’esempio dato nella domanda. Ma, credo che questa logica possa essere applicata.

In alternativa alle precedenti risposte, l’API Splitter di guava può essere utilizzata se si devono applicare altre operazioni alle linee risultanti, come ad esempio tagliare le linee o filtrare le linee vuote:

 import com.google.common.base.Splitter; Iterable split = Splitter.onPattern("\r?\n").trimResults().omitEmptyStrings().split(docStr); 

Si noti che il risultato è un Iterable e non un array.

Una nuova lines metodo è stata introdotta nella class String in java-11 , che restituisce Stream

Restituisce un stream di sottostringhe estratte da questa stringa partizionata da terminatori di riga.

I terminatori di linea riconosciuti sono line feed “\ n” (U + 000A), ritorno a capo “\ r” (U + 000D) e un ritorno a capo seguito immediatamente da un avanzamento riga “\ r \ n” (U + 000D U + 000A ).

Ecco alcuni esempi:

 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 # linee ()

• prova questa speranza è stato utile per te

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

Esistono tre diverse convenzioni (si potrebbe dire che si tratta di standard di fatto ) per impostare e visualizzare un’interruzione di riga:

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

In alcuni editor di testo è ansible scambiarne uno con l’altro:

La cosa più semplice è normalizzare il line feed e poi dividere.

 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