Split Java String von New Line

https://stackoverflow.com/questions/454908

19-08-2019
|

Frage

Ich versuche, Text in einem JTextArea mit einem regulären Ausdruck zu teilen den String von \n jedoch zu spalten, funktioniert das nicht und ich habe auch versucht, durch \r\n|\r|n und viele andere Kombination von regulären Ausdrücken. 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");
}

Lösung

Das sollten Sie decken:

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

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

Andere Tipps

Wenn Sie nicht möchten, dass leere Zeilen:

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

split Methode ist die Verwendung regex (reguläre Ausdrücke). Da Java 8 regex unterstützt \R, die (von Dokumentation steht der Klasse Pattern ):

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

So wir es verwenden können übereinstimmen:

\u000D\000A -> \r\n Paar
\ u000A -> Zeilenvorschub (\n)
\ u000B -> Linie Auftabellierung (nicht verwechseln mit Charakter Auftabellierung \t href="http://www.fileformat.info/info/unicode/char/0009/index.htm" die \u0009 ist)
\ u000C -> Formularvorschub (\f)
\ u000d -> Wagenrücklauf (\r)
\ u0085 -> nächste Zeile (NEL)
\ u2028 -> Zeilentrenner
\ u2029 -> Absatz Separator

Wie Sie \r\n sehen ist am Anfang des Regex platziert, die die Regex gewährleistet wird versuchen, diese passen Paar zuerst, und nur dann, wenn das Spiel ausfällt wird es versuchen, passen einzelnes Zeichen Zeilenseparatoren.

Wenn Sie also auf der Linie Separator Verwendung split("\\R") aufzuspalten.

Wenn Sie wollen nicht von entfernen resultierenden Array leere Strings Hinter "" verwenden split(regex, limit) mit negativen limit Parameter wie split("\\R", -1).

Wenn Sie eine oder mehrere behandeln leere Zeilen als einzelne Trennzeichen verwenden split("\\R+") weiter.

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

Das sollte System unabhängig sein

Sie müssen Zeichen in Zeichengruppen nicht verdoppeln entkommen.

Für alle nicht leere Zeilen verwenden:

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

Vielleicht wäre diese Arbeit:

die doppelten Schrägstriche aus dem Parameter der Split-Methode entfernen:

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

Eine neue Methode lines wird eingeführt, um String Klasse in java-11 , die Stream<String>

Gibt einen Strom von Teilstrings aus dieser Zeichenfolge extrahiert partitioniert   Zeile Terminatoren.

Line Terminatoren erkannt sind Zeilenvorschub "\ n" (U + 000A), die Beförderung   return "\ r" (U + 000D) und ein Wagenrücklauf, unmittelbar gefolgt von einem   line feed "\ r \ n" (U + 000D + 000A U).

Hier sind 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 ()

Alle hier gegebenen Antworten respektieren eigentlich nicht Javas Definition neuer Linien wie in Beispiel gegeben BufferedReader # Readline-. Java akzeptiert \n, \r und \r\n als neue Zeile. Einige der Antworten entsprechen mehrere leere Zeilen oder fehlerhafte Dateien. Z.B. <sometext>\n\r\n<someothertext> wenn in zwei Linien [\r\n]+would belegt wird.

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

Im Gegensatz dazu hat die Antwort über die folgenden Eigenschaften:

Sie erfüllt Javas Definition einer neuen Zeile wie z.B. die BufferedReader nutzt das
es nicht mehr neue Linien entspricht
es nicht entfernt leere Zeilen Hinter

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

Rückkehr einen Strom von Zeilen aus dieser Zeichenfolge extrahiert, getrennt durch Linie Terminatoren.

Ferner ist die Dokumentation geht weiter zu sagen:

Ein Leitungsabschluss ist einer der folgenden: einem Zeilenvorschub-Zeichen „\ n“ (U + 000A), ein Wagenrücklaufzeichen "\ r" (U + 000D) oder ein Schlitten return unmittelbar gefolgt von einem Zeilenvorschub "\ r \ n" (U + 000D + 000A U). EIN Linie entweder eine Sequenz von null oder mehr Zeichen, gefolgt von einem Leitungsabschluss, oder es ist eine Folge von einem oder mehreren Zeichen bis zum Ende des Strings gefolgt. Eine Zeile enthält nicht die Linie Terminator.

Mit diesem kann man einfach tun:

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

dann, wenn Sie einen Array wollen:

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

Diese Methode Da gibt einen Stream zurück es auf sich für Sie eine Menge von Optionen, wie es ein prägnante und deklarative Ausdruck möglicherweise parallele Operationen schreiben können.

Für leere Zeilen aus immer zerquetscht Verwendung Erhaltung:

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

Der obige Code tut tun wirklich etwas zu sehen - es ist nur calcualtes Dumps dann die Berechnung. Ist es der Code, den Sie verwendet wird, oder nur ein Beispiel für diese Frage?

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

Wenn aus irgendeinem Grund, Sie nicht wollen, String.split verwenden (zum Beispiel wegen reguläre Ausdrücke ) und Sie mögen auf Java 8 funktionale Programmierung verwenden oder neuer:

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

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

Nach Versuchen auf der Grundlage aller gegebenen Lösungen gescheitert. Ich ersetze \n mit einem besonderen Wort und dann gespalten. Für mich ist der Trick folgenden haben:

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

Ich kann nicht das Beispiel replizieren in der Frage gegeben. Aber ich denke, diese Logik angewandt werden kann.

Als Alternative zu den früheren Antworten, Guave der Splitter API verwendet werden kann, wenn andere Vorgänge auf die resultierenden Linien aufgebracht werden sollen, wie Linien oder Filterung Leerzeilen Besatz:

import com.google.common.base.Splitter;

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

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

versuchen, diese Hoffnung, die für Sie hilfreich

 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 (könnte man sagen, dass diejenigen sind de facto Standards) zu setzen und einen Zeilenumbruch angezeigt werden:

carriage return + line feed
line feed
carriage return

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

Notepad ++

Die einfachste Sache zu normalisieren dann Split line feedand.

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

Es gibt neuen Jungen in der Stadt, so müssen Sie nicht mit alle über Komplexität zu bewältigen. Von JDK 11 weiter , müssen nur als einzige Zeile Code schreiben, wird es Zeilen aufgeteilt und kehrt Strom 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/en/java/javase/11/docs/api/java.base/java/lang/String.html#lines () https://www.azul.com/90 -neue-Features-and-apis-in-jdk-11 /

Ich hoffe, das jemand hilfreich sein wird. Glückliche Codierung.

Die oben genannten Antworten halfen mir nicht auf Android, dank der Pshemo Antwort, die für mich auf Android gearbeitet. Ich werde einige von Pshemo Antwort hier:

split("\\\\n")

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

}

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow