Dividi Java String per New Line

Sto cercando di dividere il testo in un JTextAreautilizzo di una regex per dividere la stringa da \nTuttavia, questo non funziona e ho anche provato da \r\n|\r|ne molte altre combinazioni di regex. Codice:

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

Questo dovrebbe coprirti:

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

Ci sono solo due newline (UNIX e Windows) di cui devi preoccuparti.

String#split​(String regex)il metodo utilizza regex (espressioni regolari). Poiché Java 8 regex supporta \Rche rappresenta (dalla documentazione della classe Pattern ):

Matcher di interruzioni di riga
\ R Qualsiasi sequenza di interruzioni di riga Unicode è equivalente a \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

Quindi possiamo usarlo per abbinare:

• \u000D\000A-> \r\ncoppia
• \ u000A -> avanzamento riga ( \n)
• \ u000B -> tabulazione di riga (NON confondere con la tabulazione dei caratteri \tche è\u0009 )
• \ u000C -> form feed ( \f)
• \ u000D -> ritorno a capo ( \r)
• \ u0085 -> riga successiva (NEL)
• \ u2028 -> separatore di riga
• \ u2029 -> separatore di paragrafo

Come vedete, \r\nviene posizionato all'inizio di regex, il che assicura che regex proverà ad abbinare prima questa coppia , e solo se quella corrispondenza fallisce, proverà ad abbinare i separatori di riga di singoli caratteri .

Quindi, se si desidera dividere il separatore in linea, utilizzare split("\\R").

Se non si desidera rimuovere dall'array risultante che segue stringhe vuote,"" utilizzare split(regex, limit)con limitparametri negativi come split("\\R", -1).

Se si desidera trattare una o più righe vuote continue come uso delimitatore singolo split("\\R+").

Se non vuoi linee vuote:

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

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

Questo dovrebbe essere indipendente dal sistema

Un nuovo metodo linesè stato introdotto per Stringclassificarejava-11, che ritorna Stream<String>

Restituisce un flusso di sottostringhe estratte da questa stringa partizionata dai terminatori di linea.

I terminatori di linea riconosciuti sono avanzamento riga "\ n" (U + 000A), ritorno a capo "\ r" (U + 000D) e un ritorno a capo seguito immediatamente da un avanzamento riga "\ r \ n" (U + 000D U + 000A ).

Ecco alcuni esempi:

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

Non è necessario duplicare i caratteri di escape nei gruppi di personaggi.

Per tutte le linee non vuote usare:

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

Nella JDK11la Stringclasse ha un lines()metodo:

Restituisce un flusso di linee estratte da questa stringa, separate da terminatori di linea.

Inoltre, la documentazione prosegue dicendo:

Un terminatore di riga è uno dei seguenti: un carattere di avanzamento riga "\ n" (U + 000A), un carattere di ritorno a capo "\ r" (U + 000D) o un ritorno a capo seguito immediatamente da un avanzamento di riga "\ r \ n "(U + 000D U + 000A). Una riga è una sequenza di zero o più caratteri seguita da un terminatore di riga oppure è una sequenza di uno o più caratteri seguita dalla fine della stringa. Una linea non include il terminatore di linea.

Con questo si può semplicemente fare:

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

quindi se vuoi un array:

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

Dato che questo metodo restituisce uno Stream su molte opzioni in quanto consente di scrivere espressioni concise e dichiarative di operazioni forse parallele.

Forse questo avrebbe funzionato:

Rimuovere le doppie barre rovesciate dal parametro del metodo split:

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

Tutte le risposte fornite qui in realtà non rispettano la definizione di Javas di nuove righe come fornita ad esempio in BufferedReader # readline. Java è accettare \n, \re \r\ncome la nuova linea. Alcune delle risposte corrispondono a più righe vuote o file non validi. Per esempio. <sometext>\n\r\n<someothertext>quando si utilizza [\r\n]+si tradurrebbe in due righe.

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

Al contrario, la risposta sopra ha le seguenti proprietà:

• è conforme alla definizione Javas di una nuova linea come ad es. BufferedReader lo sta utilizzando
• non corrisponde a più nuove righe
• non rimuove le righe vuote finali

Se, per qualche motivo, non si desidera utilizzare String.split(ad esempio, a causa di espressioni regolari ) e si desidera utilizzare la programmazione funzionale su Java 8 o versioni successive:

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

Per preservare le righe vuote dall'uso schiacciato:

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

Il codice sopra non fa effettivamente nulla di visibile - solo calcualtes quindi scarica il calcolo. È il codice che hai usato o solo un esempio per questa domanda?

prova a fare textAreaDoc.insertString (int, String, AttributeSet) alla fine?

In alternativa alle risposte precedenti, l' SplitterAPI di guava può essere utilizzata se altre operazioni devono essere applicate alle linee risultanti, come tagliare le linee o filtrare le linee vuote:

import com.google.common.base.Splitter;

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

Si noti che il risultato è Iterableun array e non un array.

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

Dopo tentativi falliti sulla base di tutte le soluzioni fornite. Sostituisco \ncon qualche parola speciale e poi divido. Per me seguire ha fatto il trucco:

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

Non ho potuto replicare l'esempio fornito nella domanda. Ma immagino che questa logica possa essere applicata.

Le risposte di cui sopra non mi hanno aiutato su Android, grazie alla risposta Pshemo che ha funzionato per me su Android. Lascerò alcune delle risposte di Pshemo qui:

split("\\\\n")

• prova questa speranza che ti sia stata utile

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

Esistono tre diverse convenzioni (si potrebbe dire che quelle sono di fatto standard) per impostare e visualizzare un'interruzione di linea:

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

In alcuni editor di testo, è possibile scambiare uno con l'altro:

La cosa più semplice è normalizzare line feede quindi dividere.

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

C'è un nuovo ragazzo in città, quindi non è necessario affrontare tutte le complessità di cui sopra. Da JDK 11 in poi , devi solo scrivere come singola riga di codice, dividerà le righe e ti restituirà Stream di 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
}}

Alcuni riferimenti https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#lines () https://www.azul.com/90-new -Caratteristiche-e-API-in-jdk-11 /

Spero che questo possa essere utile a qualcuno. Buona codifica.

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

}