Java-String nach neuer Zeile teilen

Ich versuche, Text in einem regulären Ausdruck JTextAreazu teilen, um den String nach zu teilen. \nDies funktioniert jedoch nicht und ich habe es auch mit \r\n|\r|nund vielen anderen Kombinationen von regulären Ausdrücken versucht . 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");
}

Dies sollte Sie abdecken:

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

Es gibt wirklich nur zwei Zeilenumbrüche (UNIX und Windows), über die Sie sich Sorgen machen müssen.

String#split​(String regex)Methode verwendet Regex (reguläre Ausdrücke). Da Java 8 Regex unterstützt, \Rwas darstellt (aus der Dokumentation der Pattern-Klasse ):

Zeilenumbruch-Matcher
\ R Jede Unicode-Zeilenumbruchsequenz entspricht \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

Wir können es also verwenden, um Folgendes abzugleichen:

• \u000D\000A-> \r\nPaar
• \ u000A -> Zeilenvorschub ( \n)
• \ u000B -> Linie Auftabellierung (nicht zu verwechseln mit Charakter tabellarische Aufstellung , \tdie ist\u0009 )
• \ u000C -> Formularfeed ( \f)
• \ u000D -> Wagenrücklauf ( \r)
• \ u0085 -> nächste Zeile (NEL)
• \ u2028 -> Zeilentrennzeichen
• \ u2029 -> Absatztrennzeichen

Wie Sie sehen, \r\nwird es am Anfang von Regex platziert, wodurch sichergestellt wird, dass Regex zuerst versucht, mit diesem Paar übereinzustimmen , und nur wenn diese Übereinstimmung fehlschlägt, wird versucht, einzelne Zeichenzeilentrennzeichen abzugleichen.

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

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

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

Wenn Sie keine Leerzeilen möchten:

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

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

Dies sollte systemunabhängig sein

Für linesden StringUnterricht in wurde eine neue Methode eingeführtJava-11, die zurückkehrt Stream<String>

Gibt einen Strom von Teilzeichenfolgen zurück, die aus dieser Zeichenfolge extrahiert wurden und durch Zeilenendezeichen unterteilt sind.

Als Endgeräte werden Zeilenvorschub "\ n" (U + 000A), Wagenrücklauf "\ r" (U + 000D) und ein Wagenrücklauf gefolgt von einem Zeilenvorschub "\ r \ n" (U + 000D U + 000A) erkannt ).

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

Sie müssen Escapezeichen in Zeichengruppen nicht verdoppeln.

Verwenden Sie für alle nicht leeren Zeilen:

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

In JDK11der StringKlasse gibt es eine lines()Methode:

Rückgabe eines aus dieser Zeichenfolge extrahierten Zeilenstroms, getrennt durch Zeilenabschlusszeichen.

In der Dokumentation heißt es weiter:

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

Damit kann man einfach machen:

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

dann, wenn Sie ein Array wollen:

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

Wenn diese Methode einen Stream zurückgibt, stehen Ihnen viele Optionen zur Verfügung, da Sie einen präzisen und deklarativen Ausdruck möglicherweise paralleler Operationen schreiben können .

Vielleicht würde das funktionieren:

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

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

Alle hier gegebenen Antworten berücksichtigen nicht die Javas-Definition neuer Zeilen, wie sie beispielsweise in BufferedReader # readline angegeben ist. Java akzeptiert \n, \rund \r\nals neue Zeile. Einige der Antworten stimmen mit mehreren Leerzeilen oder fehlerhaften Dateien überein. Z.B. <sometext>\n\r\n<someothertext>bei Verwendung [\r\n]+würde in zwei Zeilen führen.

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

Im Gegensatz dazu hat die obige Antwort die folgenden Eigenschaften:

• Es entspricht der Javas-Definition einer neuen Zeile, z. B. wenn der BufferedReader sie verwendet
• Es stimmt nicht mit mehreren neuen Zeilen überein
• Nachgestellte Leerzeilen werden nicht entfernt

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

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

Um zu verhindern, dass leere Zeilen gequetscht werden, verwenden Sie:

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

Der obige Code macht eigentlich nichts Sichtbares - er berechnet nur die Daten und gibt dann die Berechnung aus. Ist es der Code, den Sie verwendet haben, oder nur ein Beispiel für diese Frage?

Versuchen Sie am Ende textAreaDoc.insertString (int, String, AttributeSet) auszuführen.

Alternativ zu den vorherigen Antworten kann die Guava- SplitterAPI verwendet werden, wenn andere Operationen auf die resultierenden Zeilen angewendet werden sollen, z. B. das Trimmen von Zeilen oder das Filtern leerer Zeilen:

import com.google.common.base.Splitter;

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

Beachten Sie, dass das Ergebnis ein Iterableund kein Array ist.

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

Nach fehlgeschlagenen Versuchen auf Basis aller gegebenen Lösungen. Ich ersetze \ndurch ein spezielles Wort und teile dann. Für mich hat folgendes den Trick gemacht:

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.

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

split("\\\\n")

• 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 sind), um einen Zeilenumbruch festzulegen und anzuzeigen:

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

In einigen Texteditoren ist es möglich, einen gegen den anderen auszutauschen:

Am einfachsten ist es, zu normalisieren line feedund dann zu teilen.

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

Es gibt einen neuen Jungen in der Stadt, so dass Sie sich nicht mit allen oben genannten Komplexitäten auseinandersetzen müssen. Ab JDK 11 müssen Sie nur noch als einzelne Codezeile schreiben. Dadurch werden die Zeilen geteilt und Sie erhalten einen Stream of String zurück.

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-new -Funktionen-und-Apis-in-JDK-11 /

Ich hoffe, das wird jemandem helfen. Viel Spaß beim Codieren.

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

}