Java-String nach neuer Zeile aufteilen

Wenn Sie keine leeren Zeilen wünschen:

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

Die split-Methode verwendet regex (reguläre Ausdrücke). Da Java 8 Regex \R unterstützt, der (aus Dokumentation der Pattern-Klasse ) repräsentiert:

Linebreak Matcher
\R Jede Unicode-Zeilenumbruchsequenz ist äquivalent zu \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

So können wir es verwenden:

• \u000D\000A -> \r\n paar 
• \u000A -> Zeilenvorschub (\n)
• \u000B -> Zeilen-Tabellierung (NICHT mit der Zeichen-Tabellierung \t verwechseln, die \u0009 ist)
• \u000C -> Formularvorschub (\f)
• \u000D -> Wagenrücklauf (\r)
• \u0085 -> nächste Zeile (NEL)
• \u2028 -> Zeilentrennzeichen
• \u2029 -> Absatztrennzeichen

Wie Sie sehen, wird \r\n am Anfang des regulären Ausdrucks platziert, wodurch sichergestellt wird, dass der reguläre Ausdruck zuerst mit diesem pair übereinstimmt. Nur wenn diese Übereinstimmung fehlschlägt, wird versucht, die Trennzeichen für die einzelnen Zeilen mit Einzelzeichen zu finden.

Wenn Sie also das Zeilentrennzeichen teilen möchten, verwenden Sie split("\\R"). 

Wenn Sie keine leeren Zeichenfolgen "" aus dem resultierenden Array entfernen möchten, verwenden Sie split(regex, limit) mit einem negativen limit-Parameter wie split("\\R", -1).

Wenn Sie eine oder mehrere leere Zeilen als einzelnes Trennzeichen behandeln möchten, verwenden Sie split("\\R+").

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

Dies sollte systemunabhängig sein

Sie müssen Escape-Zeichen in Zeichengruppen nicht verdoppeln.

Für alle nicht leeren Zeilen verwenden Sie:

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

Vielleicht würde das funktionieren:

Entfernen Sie die doppelten Backslashes aus dem Parameter der Split-Methode:

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

Eine neue Methode lines wurde für die Klasse String in Java-11 eingeführt, die Stream<String> zurückgibt.

Gibt einen Stream von Teilzeichenfolgen zurück, die aus dieser Zeichenfolge extrahiert wurden durch Leitungsabschlusszeichen.

Erkannte Leitungsenden sind Zeilenvorschub "\ n" (U + 000A), Wagen return "\ r" (U + 000D) und ein Wagenrücklauf gefolgt von einem Zeilenvorschub "\ r\n" (U + 000D U + 000A).

Hier einige Beispiele: 

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

Um leere Zeilen vor dem Quetschen zu bewahren, verwenden Sie:

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

Bei allen hier gegebenen Antworten wird die Javas Definition neuer Zeilen nicht berücksichtigt, wie z. BufferedReader # readline. Java akzeptiert \n, \r und \r\n als neue Zeile. Einige Antworten stimmen mit mehreren leeren Zeilen oder fehlerhaften Dateien überein. Z.B. <sometext>\n\r\n<someothertext> würde bei Verwendung von [\r\n]+ zwei Zeilen ergeben. 

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

Im Gegensatz dazu hat die Antwort oben die folgenden Eigenschaften:

• es entspricht der Javas-Definition einer neuen Zeile, z. der BufferedReader verwendet es
• es passt nicht zu mehreren neuen Zeilen 
• leere Zeilen werden dabei nicht entfernt

Der obige Code macht eigentlich nichts sichtbares - er berechnet nur die Berechnungen. Ist es der von Ihnen verwendete Code oder nur ein Beispiel für diese Frage? 

versuchen Sie textAreaDoc.insertString (int, String, AttributeSet) am Ende?

Wenn Sie aus irgendeinem Grund String.split nicht verwenden möchten (z. B. wegen regulärer Ausdrücke ) und die funktionale Programmierung auf Java 8 oder neuer verwenden möchten:

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

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

In JDK11 hat die String-Klasse eine lines()-Methode:

Rückgabe eines aus dieser Zeichenfolge extrahierten Zeilenstroms, getrennt durch Leitungsabschlusswiderstände. 

Die Dokumentation fährt fort zu sagen:

Ein Zeilenabschlusszeichen ist eines der folgenden: ein Zeilenvorschubzeichen "\ n" (U + 000A), ein Wagenrücklaufzeichen "\ r" (U + 000D) oder ein Wagen Rückkehr gefolgt von einem Zeilenvorschub "\ r\n" (U + 000D U + 000A). EIN Zeile ist entweder eine Folge von null oder mehr Zeichen, gefolgt von einem Zeilenabschlusszeichen, oder es ist eine Folge von einem oder mehreren Zeichen gefolgt vom Ende der Zeichenfolge. Eine Zeile enthält nicht die Zeile Terminator.

Mit diesem kann man einfach tun:

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

dann, wenn Sie ein Array wünschen:

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

Wenn diese Methode einen Stream zurückgibt, werden viele Optionen für Sie zurückgegeben, da Sie concise und deklarative Ausdrücke möglicherweise paralleler Operationen schreiben können.

Nach fehlgeschlagenen Versuchen auf Basis aller gegebenen Lösungen. Ich ersetze \n durch ein spezielles Word und teile es dann auf. Für mich folgte der Trick:

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

Ich konnte das in der Frage angegebene Beispiel nicht wiederholen. Aber ich denke, diese Logik kann angewendet werden.

Als Alternative zu den vorherigen Antworten kann die Splitter-API von Guava verwendet werden, wenn andere Operationen auf die resultierenden Zeilen angewendet werden sollen, wie z. B. das Zuschneiden von Zeilen oder das Filtern von leeren Zeilen:

import com.google.common.base.Splitter;

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

Beachten Sie, dass das Ergebnis eine Iterable und kein Array ist.

• versuchen Sie diese Hoffnung, es war hilfreich für Sie 

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

Es gibt drei verschiedene Konventionen (man könnte sagen, dass dies de facto Standards), um einen Zeilenumbruch festzulegen und anzuzeigen:

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

In einigen Texteditoren ist es möglich, eine für die andere auszutauschen:

Am einfachsten ist es, auf line feed zu normieren und dann zu teilen.

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

Die obigen Antworten haben mir auf Android nicht geholfen, dank der Antwort Pshemo , die auf Android für mich funktioniert hat. Ich werde einige von Pshemos Antwort hier lassen:

split("\\\\n")

Es gibt einen neuen Jungen in der Stadt, so dass Sie sich nicht mit allen oben genannten Komplexitäten befassen müssenAb JDK 11, Sie müssen nur als einzelne Codezeile schreiben, es wird Zeilen aufgeteilt und Sie zurückgegeben Stream von String.

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

Einige Referenzen . https://docs.Oracle.com/de/Java/javase/11/docs/api/Java.base/Java/lang/String.html#lines ()https://www.azul.com/90-neue-funktionen-und-apis-in-jdk-11/

Ich hoffe, das wird jemandem helfen. Glückliche Kodierung.