Dividir Java String por nova linha

Estou tentando dividir o texto em um JTextAreausando uma regex para dividir a String por \nNo entanto, isso não funciona e também tentei por \r\n|\r|ne muitas outras combinações de regexes. Código:

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

Isso deve cobrir você:

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

Existem apenas duas novas linhas (UNIX e Windows) com as quais você precisa se preocupar.

String#split​(String regex)O método está usando regex (expressões regulares). Como o Java 8 regex suporta o \Rque representa (da documentação da classe Pattern ):

Matcher de quebra de linha
\ R Qualquer sequência de quebra de linha Unicode é equivalente a \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

Para que possamos usá-lo para combinar:

• \u000D\000A-> \r\npar
• \ u000A -> avanço de linha ( \n)
• \ u000B -> tabulação de linha (NÃO confunda com a tabulação de caracteres \tque é\u0009 )
• \ u000C -> feed de formulário ( \f)
• \ u000D -> retorno de carro ( \r)
• \ u0085 -> próxima linha (NEL)
• \ u2028 -> separador de linhas
• \ u2029 -> separador de parágrafos

Como você vê, \r\né colocado no início do regex, o que garante que o regex tentará corresponder esse par primeiro e, somente se essa correspondência falhar, ele tentará corresponder aos separadores de linha de caracteres únicos .

Portanto, se você deseja dividir no separador de linha, use split("\\R").

Se você não deseja remover da matriz resultante, as seqüências de caracteres vazias são"" usadas split(regex, limit)com limitparâmetros negativos como split("\\R", -1).

Se você deseja tratar uma ou mais linhas vazias contínuas como uso de delimitador único split("\\R+").

Se você não quiser linhas vazias:

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

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

Isso deve ser independente do sistema

Um novo método linesfoi introduzido na Stringclasse emjava-11, que retorna Stream<String>

Retorna um fluxo de substrings extraídos dessa string particionada por terminadores de linha.

Terminadores de linha reconhecidos são avanço de linha "\ n" (U + 000A), retorno de carro "\ r" (U + 000D) e retorno de carro seguido imediatamente por um avanço de linha "\ r \ n" (U + 000D U + 000A )

Aqui estão alguns exemplos:

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

Você não precisa dobrar caracteres de escape em grupos de caracteres.

Para todas as linhas não vazias, use:

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

JDK11Na Stringclasse tem um lines()método:

Retornando um fluxo de linhas extraídas dessa sequência, separadas por terminadores de linha.

Além disso, a documentação continua dizendo:

Um terminador de linha é um dos seguintes: um caractere de avanço de linha "\ n" (U + 000A), um caractere de retorno de carro "\ r" (U + 000D) ou um retorno de carro seguido imediatamente por um avanço de linha "\ r \ n "(U + 000D U + 000A). Uma linha é uma sequência de zero ou mais caracteres seguida por um terminador de linha, ou é uma sequência de um ou mais caracteres seguida pelo final da sequência. Uma linha não inclui o terminador de linha.

Com isso, pode-se simplesmente fazer:

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

então se você deseja uma matriz:

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

Dado que esse método retorna um Stream, ele oferece muitas opções, pois permite escrever expressões concisas e declarativas de operações possivelmente paralelas.

Talvez isso funcione:

Remova as barras invertidas duplas do parâmetro do método de divisão:

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

Todas as respostas fornecidas aqui, na verdade, não respeitam a definição de novas linhas do Javas, como em, por exemplo, BufferedReader # readline. Java está aceitando \n, \re \r\ncomo nova linha. Algumas das respostas correspondem a várias linhas vazias ou arquivos malformados. Por exemplo. <sometext>\n\r\n<someothertext>o uso [\r\n]+resultaria em duas linhas.

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

Por outro lado, a resposta acima tem as seguintes propriedades:

• está em conformidade com a definição de Javas de uma nova linha, como por exemplo, o BufferedReader está usando
• não corresponde a várias novas linhas
• ele não remove as linhas vazias à direita

Se, por algum motivo, você não desejar usar String.split(por exemplo, devido a expressões regulares ) e desejar usar a programação funcional no Java 8 ou mais recente:

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

Para evitar que linhas vazias sejam esmagadas, use:

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

O código acima não faz nada visível - apenas calcula e depois despeja o cálculo. É o código que você usou ou apenas um exemplo para esta pergunta?

tente fazer textAreaDoc.insertString (int, String, AttributeSet) no final?

Como alternativa às respostas anteriores, a SplitterAPI da goiaba pode ser usada se outras operações forem aplicadas às linhas resultantes, como aparar linhas ou filtrar linhas vazias:

import com.google.common.base.Splitter;

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

Observe que o resultado é um Iterablee não um array.

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

Após tentativas fracassadas com base em todas as soluções fornecidas. Eu substituo \npor alguma palavra especial e depois divido. Para mim, segui o truque:

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

Não pude replicar o exemplo dado na pergunta. Mas acho que essa lógica pode ser aplicada.

As respostas acima não me ajudaram no Android, graças à resposta Pshemo que funcionou para mim no Android. Vou deixar aqui algumas das respostas de Pshemo :

split("\\\\n")

• tente esta esperança foi útil para você

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

Existem três convenções diferentes (pode-se dizer que esses são padrões de fato ) para definir e exibir uma quebra de linha:

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

Em alguns editores de texto, é possível trocar um pelo outro:

A coisa mais simples é normalizar line feede depois dividir.

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

Há um garoto novo na cidade, então você não precisa lidar com todas as complexidades acima. A partir do JDK 11 , basta escrever como uma única linha de código, ele dividirá as linhas e retornará o Stream of 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
}}

Algumas referências. 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 /

Espero que isso seja útil para alguém. Feliz codificação.

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

}