Podziel ciąg Java według nowej linii

Próbuję podzielić tekst za JTextAreapomocą wyrażenia regularnego, aby podzielić ciąg według. \nJednak to nie działa, a także próbowałem przez \r\n|\r|ni wiele innych kombinacji wyrażeń regularnych. Kod:

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

Powinno to obejmować:

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

Tak naprawdę są tylko dwie nowe linie (UNIX i Windows), o które musisz się martwić.

String#split​(String regex)Metoda używa wyrażeń regularnych (wyrażeń regularnych). Ponieważ regex Java 8 obsługuje to, \Rco reprezentuje (z dokumentacji klasy Pattern ):

Dopasowywanie podziału linii
\ R Każda sekwencja podziału linii kodu Unicode jest równoważna \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

Możemy więc użyć go do dopasowania:

• \u000D\000A-> \r\npara
• \ u000A -> przesunięcie wiersza ( \n)
• \ u000B -> tabulacja linii (NIE mylić z tabelą znaków, \tktóra jest\u0009 )
• \ u000C -> formularz feed ( \f)
• \ u000D -> powrót karetki ( \r)
• \ u0085 -> następna linia (NEL)
• \ u2028 -> separator linii
• \ u2029 -> separator akapitu

Jak widać, \r\numieszczany jest na początku wyrażenia regularnego, co zapewnia, że ​​wyrażenie regularne spróbuje najpierw dopasować tę parę , i tylko jeśli to dopasowanie się nie powiedzie, spróbuje dopasować separatory pojedynczych znaków .

Więc jeśli chcesz podzielić separator liniowy, użyj split("\\R").

Jeśli nie chcesz usuwać z wynikowej tablicy pustych ciągów znaków,"" użyj parametru split(regex, limit)ujemnego limit, takiego jak split("\\R", -1).

Jeśli chcesz traktować jedną lub więcej kontynuuj puste linie jako pojedynczy separator split("\\R+").

Jeśli nie chcesz pustych linii:

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

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

Powinno to być niezależne od systemu

linesDo Stringklasy wprowadzono nową metodęjava-11, która zwraca Stream<String>

Zwraca strumień podciągów wyodrębniony z tego ciągu podzielonego przez terminatory linii.

Rozpoznawane terminatory linii to podawanie wiersza „\ n” (U + 000A), powrót karetki „\ r” (U + 000D) i powrót karetki, a następnie natychmiast przejście do wiersza „\ r \ n” (U + 000D U + 000A ).

Oto kilka przykładów:

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

Ciąg # linii ()

Nie musisz podwójnie uciekać postaci w grupach postaci.

Dla wszystkich niepustych linii użyj:

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

W JDK11tej Stringklasie ma lines()metodę:

Zwracanie strumienia linii wyodrębnionych z tego ciągu, oddzielonych terminatorami linii.

Ponadto dokumentacja mówi dalej:

Terminator linii jest jednym z następujących: znak przejścia do wiersza „\ n” (U + 000A), znak powrotu karetki „\ r” (U + 000D) lub znak powrotu karetki, po którym następuje natychmiast przejście do wiersza „\ r \ n "(U + 000D U + 000A). Linia jest albo sekwencją zerową lub większą liczbą znaków, po której następuje terminator linii, albo sekwencją jednego lub więcej znaków, po której następuje koniec łańcucha. Linia nie zawiera terminatora linii.

Dzięki temu można po prostu:

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

to jeśli chcesz tablicę:

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

Biorąc pod uwagę, że ta metoda zwraca strumień, pojawia się wiele opcji, ponieważ umożliwia napisanie zwięzłego i deklaratywnego wyrażenia możliwych równoległych operacji.

Może to zadziała:

Usuń podwójne ukośniki odwrotne z parametru metody podziału:

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

Wszystkie podane tutaj odpowiedzi faktycznie nie są zgodne z definicją nowych wierszy w języku JavaScript, jak podano np. W BufferedReader # readline. Java jest przyjęcie \n, \ra \r\njako nowej linii. Niektóre odpowiedzi pasują do wielu pustych linii lub zniekształconych plików. Na przykład. <sometext>\n\r\n<someothertext>przy użyciu [\r\n]+spowoduje dwa wiersze.

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

Natomiast powyższa odpowiedź ma następujące właściwości:

• jest zgodny z definicją nowej linii w języku JavaScript, np. używa go BufferedReader
• nie pasuje do wielu nowych linii
• nie usuwa końcowych pustych linii

Jeśli z jakiegoś powodu nie chcesz używać String.split(na przykład z powodu wyrażeń regularnych ) i chcesz używać programowania funkcjonalnego w Javie 8 lub nowszej:

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

Aby uchronić puste linie przed zgnieceniem, użyj:

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

Powyższy kod nie robi nic widocznego - po prostu calcualtes, a następnie zrzuca obliczenia. Czy to kod, którego użyłeś, czy tylko przykład tego pytania?

spróbować zrobić textAreaDoc.insertString (int, String, AttributeSet) na końcu?

Alternatywnie do poprzednich odpowiedzi Splittermożna użyć interfejsu API guava, jeśli do linii wynikowych mają zostać zastosowane inne operacje, takie jak przycinanie linii lub filtrowanie pustych linii:

import com.google.common.base.Splitter;

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

Zauważ, że wynikiem jest Iterabletablica, a nie tablica.

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

Po nieudanych próbach na podstawie wszystkich podanych rozwiązań. Wymieniam\n specjalne słowo, a następnie dzielę. Dla mnie następowała sztuczka:

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

Nie mogłem powtórzyć przykładu podanego w pytaniu. Ale myślę, że tę logikę można zastosować.

Powyższe odpowiedzi nie pomogły mi na Androidzie, dzięki odpowiedzi Pshemo, która działała dla mnie na Androidzie. Pozostawię tutaj odpowiedź Pshemo :

split("\\\\n")

• wypróbuj tę nadzieję, że była dla Ciebie pomocna

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

Istnieją trzy różne konwencje (można powiedzieć, że są to de facto standardy) do ustawiania i wyświetlania podziału linii:

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

W niektórych edytorach tekstu można wymienić jeden na drugi:

Najprostszą rzeczą jest normalizacja, line feeda następnie podział.

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

W mieście jest nowy chłopiec, więc nie musisz zajmować się wszystkimi powyższymi złożonościami. Począwszy od JDK 11 , wystarczy pisać jako pojedynczy wiersz kodu, dzieli linie i zwraca Strumień ciągu.

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

Niektóre referencje. https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#lines () https://www.azul.com/90-new -features-and-apis-in-jdk-11 /

Mam nadzieję, że to będzie komuś pomocne. Szczęśliwego kodowania.

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

}