Tách chuỗi Java theo dòng mới

Tôi đang cố gắng phân tách văn bản JTextAreabằng cách sử dụng biểu thức chính quy để phân tách Chuỗi theo \nTuy nhiên, điều này không hoạt động và tôi cũng đã thử \r\n|\r|nvà nhiều tổ hợp biểu thức chính khác. Mã số:

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

Điều này sẽ bao gồm bạn:

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

Thực sự chỉ có hai dòng mới (UNIX và Windows) mà bạn cần phải lo lắng.

String#split​(String regex)phương thức đang sử dụng regex (biểu thức chính quy). Do regex Java 8 hỗ trợ \Rđại diện (từ tài liệu của lớp Mẫu ):

Bộ so khớp linebreak
\ R Bất kỳ chuỗi ngắt dòng Unicode nào, tương đương với \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]

Vì vậy, chúng ta có thể sử dụng nó để phù hợp:

• \u000D\000A-> \r\ncặp
• \ u000A -> nguồn cấp dữ liệu ( \n)
• \ u000B -> lập bảng dòng (Đừng nhầm lẫn với nhân vật lập bảng \tđó là\u0009 )
• \ u000C -> dạng thức ăn ( \f)
• \ u000D -> vận chuyển trở lại ( \r)
• \ u0085 -> dòng tiếp theo (NEL)
• \ u2028 -> dấu phân cách dòng
• \ u2029 -> phân cách đoạn

Như bạn thấy \r\nđược đặt ở đầu regex, điều này đảm bảo rằng regex sẽ cố gắng khớp cặp này trước, và chỉ khi trận đấu đó thất bại, nó sẽ cố gắng khớp với các dấu phân cách dòng ký tự đơn .

Vì vậy, nếu bạn muốn phân chia sử dụng phân cách dòng split("\\R").

Nếu bạn không muốn loại bỏ khỏi chuỗi kết quả, các chuỗi trống"" sử dụng split(regex, limit)với limittham số âm như thế nào split("\\R", -1).

Nếu bạn muốn coi một hoặc nhiều dòng tiếp tục là sử dụng dấu phân cách đơn split("\\R+").

Nếu bạn không muốn dòng trống:

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

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

Điều này nên độc lập với hệ thống

Một phương thức mới linesđã được giới thiệu cho Stringlớp trongjava-11, trả lại Stream<String>

Trả về một luồng các chuỗi con được trích xuất từ ​​chuỗi này được phân vùng bởi các đầu cuối dòng.

Thiết bị đầu cuối dòng được nhận dạng là nguồn cấp dữ liệu "\ n" (U + 000A), trả lại vận chuyển "\ r" (U + 000D) và trả lại vận chuyển ngay sau nguồn cấp dữ liệu "\ r \ n" (U + 000D U + 000A ).

Đây là vài ví dụ:

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

Chuỗi # dòng ()

Bạn không phải nhân đôi lối thoát trong các nhóm nhân vật.

Đối với tất cả các dòng không trống sử dụng:

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

Trong JDK11các Stringlớp học có một lines()phương pháp:

Trả về một dòng các dòng được trích xuất từ ​​chuỗi này, được phân tách bằng các đầu cuối dòng.

Hơn nữa, các tài liệu tiếp tục nói:

Bộ kết thúc dòng là một trong những điều sau đây: ký tự nguồn cấp dữ liệu "\ n" (U + 000A), ký tự trả về vận chuyển "\ r" (U + 000D) hoặc trả về vận chuyển ngay sau nguồn cấp dữ liệu dòng "\ r \ n "(U + 000D U + 000A). Một dòng là một chuỗi gồm 0 hoặc nhiều ký tự được theo sau bởi dấu kết thúc dòng hoặc nó là một chuỗi gồm một hoặc nhiều ký tự theo sau là cuối chuỗi. Một dòng không bao gồm dấu kết thúc dòng.

Với điều này chỉ có thể làm:

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

sau đó nếu bạn muốn một mảng:

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

Đưa ra phương thức này trả về một luồng cho nó rất nhiều tùy chọn cho bạn vì nó cho phép người ta viết biểu thức súc tích và khai báo của các hoạt động có thể song song.

Có lẽ điều này sẽ làm việc:

Xóa các dấu gạch chéo kép khỏi tham số của phương thức phân tách:

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

Tất cả các câu trả lời được đưa ra ở đây thực sự không tôn trọng định nghĩa của Javas về các dòng mới như được đưa ra trong ví dụ: BufferedReader # readline. Java được chấp nhận \n, \rvà \r\nnhư dòng mới. Một số câu trả lời khớp với nhiều dòng trống hoặc tệp không đúng định dạng. Ví dụ. <sometext>\n\r\n<someothertext>khi sử dụng [\r\n]+sẽ dẫn đến hai dòng.

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

Ngược lại, câu trả lời ở trên có các thuộc tính sau:

• nó tuân thủ định nghĩa của Javas về một dòng mới, ví dụ như BufferedReader đang sử dụng nó
• nó không khớp với nhiều dòng mới
• nó không xóa các dòng trống

Nếu, vì một số lý do, bạn không muốn sử dụng String.split(ví dụ: vì các biểu thức thông thường ) và bạn muốn sử dụng lập trình chức năng trên Java 8 hoặc mới hơn:

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

Để bảo quản các dòng trống khỏi bị nghiền nát sử dụng:

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

Đoạn mã trên không thực sự làm bất cứ điều gì có thể nhìn thấy - nó chỉ là calcualte sau đó bỏ qua phép tính. Đây có phải là mã bạn đã sử dụng, hoặc chỉ là một ví dụ cho câu hỏi này?

thử làm textAreaDoc.insertString (int, String, Attributionset) ở cuối?

Thay thế cho các câu trả lời trước, SplitterAPI của ổi có thể được sử dụng nếu các hoạt động khác được áp dụng cho các dòng kết quả, như cắt các dòng hoặc lọc các dòng trống:

import com.google.common.base.Splitter;

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

Lưu ý rằng kết quả là một Iterablevà không phải là một mảng.

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

Sau những nỗ lực thất bại trên cơ sở của tất cả các giải pháp được đưa ra. Tôi thay thế \nbằng một số từ đặc biệt và sau đó chia tách. Đối với tôi sau đây đã thực hiện các mẹo:

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

Tôi không thể lặp lại ví dụ được đưa ra trong câu hỏi. Nhưng, tôi đoán logic này có thể được áp dụng.

Các câu trả lời trên không giúp ích gì cho tôi trên Android, nhờ phản hồi của Pshemo hoạt động với tôi trên Android. Tôi sẽ để lại một số câu trả lời của Pshemo tại đây:

split("\\\\n")

• Hãy thử hy vọng nó hữu ích cho bạn

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

Có ba quy ước khác nhau (có thể nói rằng đó là những tiêu chuẩn thực tế ) để thiết lập và hiển thị ngắt dòng:

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

Trong một số trình soạn thảo văn bản, có thể trao đổi cái này với cái khác:

Điều đơn giản nhất là bình thường hóa line feedvà sau đó phân chia.

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

Có một cậu bé mới trong thị trấn, vì vậy bạn không cần phải đối phó với tất cả những sự phức tạp ở trên. Từ JDK 11 trở đi , chỉ cần viết dưới dạng một dòng mã, nó sẽ phân chia các dòng và trả về cho bạn 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
}}

Một số tài liệu tham khảo. https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#lines () https://www.azul.com/90-new -features-và-apis-in-jdk-11 /

Tôi hy vọng điều này sẽ hữu ích cho ai đó. Chúc mừng mã hóa.

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

}