Cách tách một chuỗi trong Java

Tôi có một chuỗi, "004-034556"mà tôi muốn chia thành hai chuỗi:

string1="004";
string2="034556";

Điều đó có nghĩa là chuỗi đầu tiên sẽ chứa các ký tự trước '-'và chuỗi thứ hai sẽ chứa các ký tự sau '-'. Tôi cũng muốn kiểm tra xem chuỗi có '-'trong đó không. Nếu không, tôi sẽ ném một ngoại lệ. Tôi có thể làm cái này như thế nào?

Chỉ cần sử dụng phương pháp thích hợp : String#split().

String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556

Lưu ý rằng điều này cần một biểu thức chính quy , vì vậy hãy nhớ thoát các ký tự đặc biệt nếu cần thiết.

có 12 ký tự với ý nghĩa đặc biệt: dấu gạch chéo ngược \, dấu mũ ^, ký hiệu đô la $, dấu chấm hoặc dấu chấm ., thanh dọc hoặc ký hiệu ống |, dấu hỏi ?, dấu hoa thị hoặc dấu sao *, dấu cộng +, dấu ngoặc đơn mở (, dấu ngoặc đơn đóng) và dấu ngoặc vuông mở [, dấu ngoặc nhọn mở {, Những ký tự đặc biệt này thường được gọi là "siêu ký tự".

Vì vậy, nếu bạn muốn phân tách trên ví dụ: period / dot .có nghĩa là " bất kỳ ký tự " nào trong regex, hãy sử dụng dấu gạch chéo ngược\ để thoát ký tự đặc biệt như vậy split("\\.")hoặc sử dụng lớp ký tự[] để thể hiện (các) ký tự chữ như vậy split("[.]")hoặc sử dụngPattern#quote() để thoát khỏi toàn bộ chuỗi như vậy split(Pattern.quote(".")).

String[] parts = string.split(Pattern.quote(".")); // Split on period.

Để kiểm tra trước nếu chuỗi chứa (các) ký tự nhất định, chỉ cần sử dụng String#contains() .

if (string.contains("-")) {
    // Split it.
} else {
    throw new IllegalArgumentException("String " + string + " does not contain -");
}

Lưu ý, điều này không có một biểu thức thông thường. Cho rằng, sử dụngString#matches() thay thế.

Nếu bạn muốn giữ lại ký tự phân tách trong các phần kết quả, thì hãy sử dụng giao diện tích cực . Trong trường hợp bạn muốn có ký tự phân tách kết thúc ở phía bên tay trái, hãy sử dụng giao diện tích cực theo ?<=nhóm tiền tố trên mẫu.

String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556

Trong trường hợp bạn muốn có ký tự phân tách kết thúc ở phía bên tay phải, hãy sử dụng giao diện tích cực bằng cách thêm tiền tố ?= nhóm trên mẫu.

String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556

Nếu bạn muốn giới hạn số phần kết quả, thì bạn có thể cung cấp số mong muốn làm đối số thứ hai của split()phương thức.

String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42

Một cách khác để xử lý chuỗi trực tiếp sẽ là sử dụng biểu thức chính quy với các nhóm bắt. Điều này có lợi thế là nó làm cho nó đơn giản để ngụ ý các ràng buộc tinh vi hơn trên đầu vào. Ví dụ: phần sau chia chuỗi thành hai phần và đảm bảo rằng cả hai chỉ bao gồm các chữ số:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

class SplitExample
{
    private static Pattern twopart = Pattern.compile("(\\d+)-(\\d+)");

    public static void checkString(String s)
    {
        Matcher m = twopart.matcher(s);
        if (m.matches()) {
            System.out.println(s + " matches; first part is " + m.group(1) +
                               ", second part is " + m.group(2) + ".");
        } else {
            System.out.println(s + " does not match.");
        }
    }

    public static void main(String[] args) {
        checkString("123-4567");
        checkString("foo-bar");
        checkString("123-");
        checkString("-4567");
        checkString("123-4567-890");
    }
}

Vì mẫu này được cố định trong trường hợp này, nó có thể được biên dịch trước và được lưu trữ dưới dạng một thành viên tĩnh (được khởi tạo tại thời điểm tải lớp trong ví dụ). Biểu thức chính quy là:

(\d+)-(\d+)

Các dấu ngoặc biểu thị các nhóm bắt giữ; chuỗi phù hợp với phần đó của biểu thức chính quy có thể được truy cập bằng phương thức Match.group (), như được hiển thị. \ D khớp và một chữ số thập phân đơn và dấu + có nghĩa là "khớp với một hoặc nhiều biểu thức trước đó). - không có ý nghĩa đặc biệt, vì vậy chỉ khớp với ký tự đó trong đầu vào. Lưu ý rằng bạn cần thoát hai dấu gạch chéo ngược khi viết đây là một chuỗi Java. Một số ví dụ khác:

([A-Z]+)-([A-Z]+)          // Each part consists of only capital letters 
([^-]+)-([^-]+)            // Each part consists of characters other than -
([A-Z]{2})-(\d+)           // The first part is exactly two capital letters,
                           // the second consists of digits

String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

Điều này sẽ chia chuỗi của bạn thành 2 phần. Phần tử đầu tiên trong mảng sẽ là phần chứa nội dung trước -phần tử và phần tử thứ 2 trong mảng sẽ chứa phần chuỗi của bạn sau phần -.

Nếu độ dài mảng không phải là 2, thì chuỗi không ở định dạng : string-string.

Kiểm tra split()phương pháp trongString lớp.

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int-

String[] out = string.split("-");

nên làm điều bạn muốn Lớp chuỗi có nhiều phương thức để hoạt động với chuỗi.

// This leaves the regexes issue out of question
// But we must remember that each character in the Delimiter String is treated
// like a single delimiter        

public static String[] SplitUsingTokenizer(String subject, String delimiters) {
   StringTokenizer strTkn = new StringTokenizer(subject, delimiters);
   ArrayList<String> arrLis = new ArrayList<String>(subject.length());

   while(strTkn.hasMoreTokens())
      arrLis.add(strTkn.nextToken());

   return arrLis.toArray(new String[0]);
}

Với Java 8:

    List<String> stringList = Pattern.compile("-")
            .splitAsStream("004-034556")
            .collect(Collectors.toList());

    stringList.forEach(s -> System.out.println(s));

Các yêu cầu còn lại để giải thích. Tôi khuyên bạn nên viết một phương pháp,

public final static String[] mySplit(final String s)

trong đó đóng gói chức năng này. Tất nhiên bạn có thể sử dụng String.split (..) như được đề cập trong các câu trả lời khác để thực hiện.

Bạn nên viết một số bài kiểm tra đơn vị cho chuỗi đầu vào và kết quả và hành vi mong muốn.

Thí sinh thi tốt nên bao gồm:

 - "0022-3333"
 - "-"
 - "5555-"
 - "-333"
 - "3344-"
 - "--"
 - ""
 - "553535"
 - "333-333-33"
 - "222--222"
 - "222--"
 - "--4555"

Với việc xác định kết quả kiểm tra theo, bạn có thể chỉ định hành vi.

Ví dụ, nếu "-333"nên quay lại [,333]hoặc nếu đó là một lỗi. Có thể "333-333-33"được tách ra [333,333-33] or [333-333,33]hoặc là một lỗi? Và như thế.

Bạn cũng có thể thử như thế này

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");

Giả sử rằng

• bạn không thực sự cần biểu thức chính quy cho sự phân chia của bạn
• bạn đã sử dụng apache commons lang trong ứng dụng của bạn

Cách dễ nhất là sử dụng StringUtils # split (java.lang.String, char) . Điều đó thuận tiện hơn so với cái được Java cung cấp ngoài hộp nếu bạn không cần các biểu thức thông thường. Giống như hướng dẫn của nó nói, nó hoạt động như thế này:

A null input String returns null.

 StringUtils.split(null, *)         = null
 StringUtils.split("", *)           = []
 StringUtils.split("a.b.c", '.')    = ["a", "b", "c"]
 StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
 StringUtils.split("a:b:c", '.')    = ["a:b:c"]
 StringUtils.split("a b c", ' ')    = ["a", "b", "c"]

Tôi khuyên bạn nên sử dụng commong-lang, vì thông thường nó chứa rất nhiều thứ có thể sử dụng được. Tuy nhiên, nếu bạn không cần nó cho bất cứ điều gì khác ngoài việc chia tách, thì tự thực hiện hoặc thoát khỏi regex là một lựa chọn tốt hơn.

Sử dụng org.apache.commons.lang.StringUtils ' phương thức phân tách có thể phân tách chuỗi dựa trên ký tự hoặc chuỗi bạn muốn tách.

Chữ ký phương thức:

public static String[] split(String str, char separatorChar);

Trong trường hợp của bạn, bạn muốn tách một chuỗi khi có dấu "-".

Bạn chỉ có thể làm như sau:

String str = "004-034556";

String split[] = StringUtils.split(str,"-");

Đầu ra:

004
034556

Giả sử rằng nếu -không tồn tại trong chuỗi của bạn, nó sẽ trả về chuỗi đã cho và bạn sẽ không nhận được bất kỳ ngoại lệ nào.

Tóm lại: có ít nhất năm cách để phân tách một chuỗi trong Java:

1. Chuỗi.split ():

   String[] parts ="10,20".split(",");

2. Pattern.compile (regrec) .splitAsStream (đầu vào):

   List<String> strings = Pattern.compile("\\|")
         .splitAsStream("010|020202")
         .collect(Collectors.toList());

3. StringTokenizer (lớp kế thừa):

   StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", ".");
   while(strings.hasMoreTokens()){
       String substring = strings.nextToken();
       System.out.println(substring);
   }

4. Google Guava Splitter:

   Iterable<String> result = Splitter.on(",").split("1,2,3,4");

5. StringUtils Apache Commons:

   String[] strings = StringUtils.split("1,2,3,4", ",");

Vì vậy, bạn có thể chọn tùy chọn tốt nhất cho mình tùy thuộc vào những gì bạn cần, ví dụ: kiểu trả về (mảng, danh sách hoặc lặp lại).

Dưới đây là một tổng quan lớn về các phương thức này và các ví dụ phổ biến nhất (cách phân tách bằng dấu chấm, dấu gạch chéo, dấu hỏi, v.v.)

Cách nhanh nhất, cũng tiêu tốn ít tài nguyên nhất có thể là:

String s = "abc-def";
int p = s.indexOf('-');
if (p >= 0) {
    String left = s.substring(0, p);
    String right = s.substring(p + 1);
} else {
  // s does not contain '-'
}

Phân chia chuỗi với nhiều ký tự bằng Regex

public class StringSplitTest {
     public static void main(String args[]) {
        String s = " ;String; String; String; String, String; String;;String;String; String; String; ;String;String;String;String";
        //String[] strs = s.split("[,\\s\\;]");
        String[] strs = s.split("[,\\;]");
        System.out.println("Substrings length:"+strs.length);
        for (int i=0; i < strs.length; i++) {
            System.out.println("Str["+i+"]:"+strs[i]);
        }
     }
  }

Đầu ra:

Substrings length:17
Str[0]:
Str[1]:String
Str[2]: String
Str[3]: String
Str[4]: String
Str[5]: String
Str[6]: String
Str[7]:
Str[8]:String
Str[9]:String
Str[10]: String
Str[11]: String
Str[12]:
Str[13]:String
Str[14]:String
Str[15]:String
Str[16]:String

Nhưng đừng mong đợi cùng một đầu ra trên tất cả các phiên bản JDK. Tôi đã thấy một lỗi tồn tại trong một số phiên bản JDK trong đó chuỗi null đầu tiên đã bị bỏ qua. Lỗi này không có trong phiên bản JDK mới nhất, nhưng nó tồn tại trong một số phiên bản giữa JDK 1.7 phiên bản muộn và 1.8 phiên bản đầu.

Đối với trường hợp sử dụng đơn giản String.split()nên làm công việc. Nếu bạn sử dụng ổi, cũng có một lớp Splitter cho phép xâu chuỗi các hoạt động chuỗi khác nhau và hỗ trợ CharMatcher :

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);

public class SplitTest {

    public static String[] split(String text, String delimiter) {
        java.util.List<String> parts = new java.util.ArrayList<String>();

        text += delimiter;

        for (int i = text.indexOf(delimiter), j=0; i != -1;) {
            String temp = text.substring(j,i);
            if(temp.trim().length() != 0) {
                parts.add(temp);
            }
            j = i + delimiter.length();
            i = text.indexOf(delimiter,j);
        }

        return parts.toArray(new String[0]);
    }


    public static void main(String[] args) {
        String str = "004-034556";
        String delimiter = "-";
        String result[] = split(str, delimiter);
        for(String s:result)
            System.out.println(s);
    }
}

Bạn có thể chia chuỗi bằng cách ngắt dòng bằng cách sử dụng câu lệnh sau:

String textStr[] = yourString.split("\\r?\\n");

Bạn có thể phân tách một chuỗi bằng dấu gạch nối / ký tự bằng cách sử dụng câu lệnh sau:

String textStr[] = yourString.split("-");

import java.io.*;

public class BreakString {

  public static void main(String args[]) {

    String string = "004-034556-1234-2341";
    String[] parts = string.split("-");

    for(int i=0;i<parts.length;i++) ｛
      System.out.println(parts[i]);
    }
  }
}

Bạn có thể sử dụng Split ():

import java.io.*;

public class Splitting
{

    public static void main(String args[])
    {
        String Str = new String("004-034556");
        String[] SplittoArray = Str.split("-");
        String string1 = SplittoArray[0];
        String string2 = SplittoArray[1];
    }
}

Khác, bạn có thể sử dụng StringTokenizer:

import java.util.*;
public class Splitting
{
    public static void main(String[] args)
    {
        StringTokenizer Str = new StringTokenizer("004-034556");
        String string1 = Str.nextToken("-");
        String string2 = Str.nextToken("-");
    }
}

Chỉ có hai phương pháp bạn thực sự cần xem xét.

Sử dụng String.split cho dấu phân cách một ký tự hoặc bạn không quan tâm đến hiệu suất

Nếu hiệu suất không phải là một vấn đề, hoặc nếu dấu phân cách là một ký tự không phải là ký tự đặc biệt biểu thức chính quy (nghĩa là không phải là một trong số .$|()[{^?*+\đó) thì bạn có thể sử dụng String.split.

String[] results = input.split(",");

Phương thức phân tách có tối ưu hóa để tránh sử dụng biểu thức chính quy nếu dấu phân cách là một ký tự đơn và không có trong danh sách trên. Mặt khác, nó phải biên dịch một biểu thức chính quy, và điều này không lý tưởng.

Sử dụng Pattern.split và biên dịch trước mẫu nếu sử dụng một dấu phân cách phức tạp và bạn quan tâm đến hiệu suất.

Nếu hiệu suất là một vấn đề và dấu phân cách của bạn không phải là một trong những điều trên, bạn nên biên dịch trước một mẫu biểu thức chính quy mà sau đó bạn có thể sử dụng lại.

// Save this somewhere
Pattern pattern = Pattern.compile("[,;:]");

/// ... later
String[] results = pattern.split(input);

Tùy chọn cuối cùng này vẫn tạo ra một Matcherđối tượng mới . Bạn cũng có thể lưu trữ đối tượng này và đặt lại cho từng đầu vào để có hiệu suất tối đa, nhưng điều đó hơi phức tạp và không an toàn cho luồng.

Một cách để làm điều này là chạy qua Chuỗi trong một vòng lặp cho mỗi vòng và sử dụng ký tự phân tách được yêu cầu.

public class StringSplitTest {

    public static void main(String[] arg){
        String str = "004-034556";
        String split[] = str.split("-");
        System.out.println("The split parts of the String are");
        for(String s:split)
        System.out.println(s);
    }
}

Đầu ra:

The split parts of the String are:
004
034556

Vui lòng không sử dụng lớp StringTokenizer vì đây là lớp kế thừa được giữ lại vì lý do tương thích và việc sử dụng nó không được khuyến khích trong mã mới. Và chúng ta cũng có thể sử dụng phương pháp phân tách theo đề xuất của người khác.

String[] sampleTokens = "004-034556".split("-");
System.out.println(Arrays.toString(sampleTokens));

Và như dự kiến, nó sẽ in:

[004, 034556]

Trong câu trả lời này, tôi cũng muốn chỉ ra một thay đổi đã xảy ra đối với splitphương thức trong Java 8 . Phương thức String # split () sử dụng Pattern.splitvà bây giờ nó sẽ loại bỏ các chuỗi trống khi bắt đầu mảng kết quả. Lưu ý sự thay đổi này trong tài liệu cho Java 8:

Khi có một kết quả chiều rộng dương ở đầu chuỗi đầu vào thì một chuỗi con hàng đầu trống được đưa vào ở đầu mảng kết quả. Tuy nhiên, một kết quả có độ rộng bằng 0 ở đầu không bao giờ tạo ra chuỗi con trống hàng đầu như vậy.

Nó có nghĩa cho ví dụ sau:

String[] sampleTokensAgain = "004".split("");
System.out.println(Arrays.toString(sampleTokensAgain));

chúng ta sẽ nhận được ba chuỗi: [0, 0, 4]và không phải bốn chuỗi như trong trường hợp Java 7 và trước đó. Cũng kiểm tra câu hỏi tương tự này .

Đây là hai cách hai đạt được nó.

CÁCH 1: Khi bạn phải chia hai số cho một ký tự đặc biệt, bạn có thể sử dụng regex

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TrialClass
{
    public static void main(String[] args)
    {
        Pattern p = Pattern.compile("[0-9]+");
        Matcher m = p.matcher("004-034556");

        while(m.find())
        {
            System.out.println(m.group());
        }
    }
}

CÁCH 2: Sử dụng phương pháp tách chuỗi

public class TrialClass
{
    public static void main(String[] args)
    {
        String temp = "004-034556";
        String [] arrString = temp.split("-");
        for(String splitString:arrString)
        {
            System.out.println(splitString);
        }
    }
}

Bạn chỉ có thể sử dụng StringTokenizer để chia một chuỗi thành hai hoặc nhiều phần cho dù có bất kỳ loại dấu phân cách nào:

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}

Kiểm tra split()phương thức trong Stringlớp trên javadoc.

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split(java.lang.String)

String data = "004-034556-1212-232-232";
int cnt = 1;
for (String item : data.split("-")) {
        System.out.println("string "+cnt+" = "+item);
        cnt++;
}

Ở đây nhiều ví dụ cho chuỗi phân tách nhưng tôi ít mã được tối ưu hóa.

String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];

Tôi chỉ muốn viết một thuật toán thay vì sử dụng các hàm dựng sẵn của Java:

public static List<String> split(String str, char c){
    List<String> list = new ArrayList<>();
    StringBuilder sb = new StringBuilder();

    for (int i = 0; i < str.length(); i++){
        if(str.charAt(i) != c){
            sb.append(str.charAt(i));
        }
        else{
            if(sb.length() > 0){
                list.add(sb.toString());
                sb = new StringBuilder();
            }
        }
    }

    if(sb.length() >0){
        list.add(sb.toString());
    }
    return list;
}

Bạn có thể sử dụng phương pháp split:

public class Demo {
    public static void main(String args[]) {
        String str = "004-034556";

        if ((str.contains("-"))) {
            String[] temp = str.split("-");
            for (String part:temp) {
                System.out.println(part);
            }
        }
        else {
            System.out.println(str + " does not contain \"-\".");
        }
    }
}

Để phân tách một chuỗi, sử dụng String.split (regex). Xem lại các ví dụ sau:

String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

Đầu ra

004
034556

Ghi chú:

Sự phân chia này (regex) lấy regex làm đối số. Nhớ thoát các ký tự đặc biệt regex, như dấu chấm / dấu chấm.

String s="004-034556";
for(int i=0;i<s.length();i++)
{
    if(s.charAt(i)=='-')
    {
        System.out.println(s.substring(0,i));
        System.out.println(s.substring(i+1));
    }
}

Như mọi người đã đề cập, split () là tùy chọn tốt nhất có thể được sử dụng trong trường hợp của bạn. Một phương pháp thay thế có thể được sử dụng chuỗi con ().

Để tách một chuỗi, sử dụng String.split(regex):

String phone = "004-034556";
String[] output = phone.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

Đầu ra:

004
034556