1.4k

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?

|
2.5k

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.

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 chia trên ví dụ như thời gian / chấm .có nghĩa là " bất kỳ nhân vật " trong regex, sử dụng một trong hai dấu chéo ngược\ để thoát khỏi nhân vật đặc biệt cá nhân như vậy split("\\."), hoặc sử dụng lớp nhân vật[] đại diện cho ký tự chữ (s) như vậy split("[.]"), hoặc sử dụng Pattern#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. Đối với điều đó, sử dụng String#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 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

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
|
  • 1

    Tại sao bạn sử dụng các ký hiệu băm để phân định các phương thức của String?

    – Tạ Nhã Uyên 08:56:08 01/08/2013
  • 1

    @Crowie: kiểu javadoc.

    – Tạ Phương Tâm 12:04:18 01/08/2013
  • 1

    Trường hợp góc: nếu không thể tìm thấy reugalr expressionnó sẽ trả về một mảng phần tử với toàn bộ chuỗi.

    – Phạm Gia Minh 12:36:35 23/05/2016
  • 1

    @BalusC những gì về trở lại?, Tham gia? cảm ơn

    – Bùi Điệp Hạ 10:05:19 28/08/2018
  • 1

    Không thể tin rằng phiên bản được bình chọn nhiều nhất là như thế này. 1) part2 không phải là những gì người đăng muốn nếu chuỗi gốc chứa hai "-" 2) Không xử lý lỗi như được đề cập trong câu hỏi. 3) Hiệu quả thấp. Một tìm kiếm ký tự duy nhất cần xây dựng biểu thức chính quy và khớp. Tạo thêm mảng, v.v.

    – Trịnh Dạ Thi 23:38:57 17/01/2019
71

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 đơn 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
|
  • 1

    Đây là một giải pháp tuyệt vời, tuy nhiên phần đầu tiên phải là m.group(1)phần thứ hai m.group(2)m.group(0)thực sự trả về mẫu phù hợp đầy đủ. Tôi nghĩ tôi cũng nhớ group(0)từng là trận đấu đầu tiên thay vì mẫu đầy đủ, có lẽ điều này đã thay đổi trong bản cập nhật phiên bản java gần đây.

    – Tạ Nhã Uyên 04:28:03 13/07/2017
  • 1

    Cảm ơn. Nhìn vào docs.oracle.com/javase/7/docs/api/java/util/regex/ mẹo , bạn đúng - phù hợp với hầu hết các thư viện regrec khác, nhóm 0 là trận đấu đầy đủ và các nhóm bị bắt bắt đầu tại 1. Như bạn nói, tôi nghi ngờ rằng điều này có thể đã thay đổi kể từ khi tôi viết câu trả lời, nhưng trong mọi trường hợp tôi sẽ cập nhật nó để phản ánh hành vi hiện tại.

    – Tạ Phương Tâm 16:09:05 17/07/2017
40
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 trong Stringlớp.

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

|
  • 1

    Điều này sẽ chấp nhận "-555" làm đầu vào và trả về [, 555]. Các yêu cầu không được xác định rõ ràng, nếu nó có giá trị để chấp nhận điều này. Tôi khuyên bạn nên viết một số bài kiểm tra đơn vị để xác định hành vi mong muốn.

    – Tạ Nhã Uyên 06:36:31 14/08/2010
  • 1

    Có lẽ an toàn nhất để thay đổi (result.length! = 2) thành (result.length <2)

    – Tạ Phương Tâm 16:53:31 10/02/2014
27
// 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]);
}
|
  • 1

    JavaDoc nêu rõ: " StringTokenizerlà một lớp kế thừa được giữ lại vì lý do tương thích mặc dù việc sử dụng nó không được khuyến khích trong mã mới . Chúng tôi khuyên mọi người tìm kiếm chức năng này nên sử dụng splitphương thức Stringhoặc java.util.regexgói."

    – Tạ Nhã Uyên 07:07:11 09/09/2013
24
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.

|
18

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 đó gói gọn 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ư vậy.

|
17

Với Java 8:

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

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

Sử dụng phương thức phân tách của org.apache.commons.lang.StringUtils 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.

|
15

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.

|
15

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

 String concatenated_String="hi^Hello";

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

Đố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);
|
13

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.

|
11

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 '-'
}
|
  • 1

    Tài nguyên khan hiếm nhất thường là thời gian và sự chú ý của lập trình viên. Mã này tiêu thụ nhiều tài nguyên đó hơn các lựa chọn thay thế.

    – Vũ Vy Lan 22:45:12 24/08/2014
  • 1

    bạn có rất nhiều tài nguyên tích hợp mà bạn có thể sử dụng, trong đó hiệu suất thực sự được xem xét, giải pháp này thiếu thời gian thực hiện hiệu suất

    – Tạ Hữu Khanh 16:50:03 22/04/2016
  • 1

    Để thực hiện phân tách đơn giản trên một ký tự đơn với kiểm tra lỗi, điều này không phức tạp hơn phiên bản regex.

    – Bùi Nguyên Văn 21:13:57 16/01/2019
  • 1

    Bravo! Cuối cùng, một câu trả lời cho câu hỏi này không sử dụng regex! Sử dụng một regex cho nhiệm vụ đơn giản này là một cái khăn trùm đầu. Thật tốt khi thấy có những lập trình viên lành mạnh vẫn còn trên trái đất này :-)

    – Dương Nhã Hồng 01:44:24 22/03/2019
10

Tóm lại: có ít nhất năm cách để 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.)

|
10
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);
    }
}
|
9
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]);
    }
  }
}
|
  • 1

    Nếu tôi có thể chia sẻ lời khuyên, làm thế nào câu trả lời của bạn mang lại nhiều giá trị hơn giải pháp đã được chấp nhận? stackoverflow.com/a 43281842/420096 trong các tình huống như vậy bạn có thể bỏ phiếu cho giải pháp hiện có, đặc biệt nếu đây là một trường hợp tầm thường rõ ràng như thế.

    – Vũ Vy Lan 03:51:30 02/10/2016
9

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

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

Đâ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);
        }
    }
}
|
7

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 hợp 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 .

|
7

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ần thiết.

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

Đôi khi nếu bạn muốn tách string containing +thì nó sẽ không tách; thay vào đó bạn sẽ nhận được một runtime error. Trong trường hợp đó, đầu tiên replace + to _và sau đó phân chia:

 this.text=text.replace("/", "_");
            String temp[]=text.split("_");
|
  • 1

    Điều này là do các đối số để phân chia là một biểu thức thông thường. Một giải pháp tốt hơn là thoát chính xác biểu thức chính quy.

    – Dương Như Ngọc 16:49:33 27/03/2013
6

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());
}
|
4
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

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

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.

|
3

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

Sử dụng String.split nếu phân định 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 ký hiệu là một ký tự đơn lẻ 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 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à đồng hồ đo 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.

|
1
 String string = "004^034556-34";
 String[] parts = string.split(Pattern.quote("^"));

Nếu bạn có một ký tự đặc biệt thì bạn có thể sử dụng Patter.quote. Nếu bạn chỉ đơn giản có dấu gạch ngang (-) thì bạn có thể rút ngắn mã:

 String string = "004-34";
 String[] parts = string.split("-");

Nếu bạn cố gắng thêm ký tự đặc biệt khác thay cho dấu gạch ngang (^) thì lỗi sẽ tạo ra ArrayIndexOutOfBoundException . Cho rằng bạn phải sử dụng Pattern.quote.

|
1

Từ tài liệu:

public String[] split(String regex,int limit) Chia chuỗi này xung quanh các kết quả khớp của biểu thức chính quy định . Mảng được trả về bởi phương thức này chứa mỗi chuỗi con của chuỗi này được kết thúc bởi một chuỗi con kháckhớp với biểu thức đã cho hoặc bị chấm dứt ở cuối chuỗi. Các chuỗi con trong mảng theo thứ tự xuất hiện trong chuỗi này. Nếu biểu thức không khớp với bất kỳ phần nào của đầu vào thì mảng kết quả chỉ có một phần tử , đó là chuỗi này.

Về cơ bản bạn có thể làm một cái gì đó như thế này:

String s = "123-456-789-123"; // The String to be split
String[] array = s.split("-"); // Split according to the hyphen and put them in an array
for(String subString : array){ // Cycle through the array
   System.out.println(subString);
}

Đầu ra:

123
456
789
123
|
1

bạn có thể sử dụng phương thức chia

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

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

Câu trả lời của bạn (> 20 ký tự)

Bằng cách click "Đăng trả lời", bạn đồng ý với Điều khoản dịch vụ, Chính sách bảo mật and Chính sách cookie của chúng tôi.

Không tìm thấy câu trả lời bạn tìm kiếm? Duyệt qua các câu hỏi được gắn thẻ hoặc hỏi câu hỏi của bạn.