Ich versuche, Text in einer JTextArea
mit einem Regex aufzuteilen, um den String durch \n
aufzuteilen. Dies funktioniert jedoch nicht und ich habe es auch mit \r\n|\r|n
und vielen anderen Kombinationen von Regexen versucht.
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 nur zwei Zeilenumbrüche (UNIX und Windows), um die Sie sich sorgen müssen.
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 \n
)\t
verwechseln, die \u0009
ist)\f
)\r
)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
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:
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.
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.