如何在Java中分割字符串


How to split a string in Java

我有一个字符串，"004-034556"，我想把它分成两个字符串：

1
2
string1="004";
string2="034556";

这意味着第一个字符串将包含'-'之前的字符，第二个字符串将包含'-'之后的字符。我还想检查字符串中是否有'-'。如果没有，我会抛出一个异常。我该怎么做？

只需使用适当的方法：String#split()。

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

请注意，这需要一个正则表达式，因此如果需要，请记住转义特殊字符。

there are 12 characters with special meanings: the backslash \, the caret ^, the dollar sign $, the period or dot ., the vertical bar or pipe symbol |, the question mark ?, the asterisk or star *, the plus sign +, the opening parenthesis (, the closing parenthesis ), and the opening square bracket [, the opening curly brace {, These special characters are often called"metacharacters".

因此，如果要拆分，例如period/dot .，在regex中表示"any character"，可以使用反斜杠\来转义单个特殊字符，如split("\\.")，或者使用字符类[]来表示文字字符，如split("[.]")，或者使用Pattern#quote()来转义整个字符串，如e所示。DOXX1〔7〕

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

要预先测试字符串是否包含某些字符，只需使用String#contains()。

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

注意，这不采用正则表达式。为此，使用String#matches()代替。

如果您希望在结果部分保留拆分字符，那么可以使用正向环顾。如果要让拆分字符以左侧结尾，请在模式上预先加上?<=组，使用正查找。

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

如果您希望拆分字符以右端结束，请在模式上预先加上?=组，使用正向前瞻。

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

如果您希望限制生成的部件的数量，那么可以提供所需的数量作为split()方法的第二个参数。

1
2
3
4
String string ="004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42
相关讨论

直接处理字符串的另一种方法是使用带捕获组的正则表达式。这样做的好处是，可以直接暗示对输入的更复杂的约束。例如，下面将字符串拆分为两部分，并确保这两部分仅由数字组成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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");
    }
}

由于模式在此实例中是固定的，因此可以预先编译并存储为静态成员(在示例中在类加载时初始化)。正则表达式是：

1
(\d+)-(\d+)

括号表示捕获组；匹配regexp部分的字符串可以通过match.group()方法访问，如图所示。d与单个十进制数字匹配，+表示"与前面的一个或多个表达式匹配"。-没有特殊含义，因此只匹配输入中的字符。注意，当编写Java字符串时，需要双击反斜杠。其他一些例子：

1
2
3
4
([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
2
3
String[] result = yourString.split("-");
if (result.length != 2)
     throw new IllegalArgumentException("String not in correct format");

这将把你的绳子分成两部分。数组中的第一个元素将是包含-之前的内容的部分，数组中的第二个元素将包含字符串中位于-之后的部分。

如果数组长度不是2，则字符串的格式不是：string-string。

查看String类中的split()方法。

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

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
// 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
String[] out = string.split("-");

应该做你想做的事。String类有许多方法可以用String操作。

这些要求留有解释的余地。我建议你写一个方法，

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

它封装了这个函数。当然，您可以使用string.split(..)作为实现的其他答案。

您应该为输入字符串和期望的结果和行为编写一些单元测试。

优秀的应试者应包括：

1
2
3
4
5
6
7
8
9
10
11
12
 -"0022-3333"
 -"-"
 -"5555-"
 -"-333"
 -"3344-"
 -"--"
 -""
 -"553535"
 -"333-333-33"
 -"222--222"
 -"222--"
 -"--4555"

通过定义相应的测试结果，您可以指定行为。

例如，如果"-333"应该返回[,333]，或者它是一个错误。"333-333-33"在[333,333-33] or [333-333,33]中能分开吗？还是错误？等等。

相关讨论

With Java 8:

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

    stringList.forEach(s -> System.out.println(s));
相关讨论

假设

  • 你不需要经常的表情
  • 你在你的应用程序中终于使用了Apache Commons Lang

简单的方式是使用弦乐 35；Split(Java.lang.string，char)。如果你不需要常规表达式的话，这比Java提供的一个更合适。就像他的手册说的，它的工作像这样：

1
2
3
4
5
6
7
8
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"]

我会用普通语言提出建议，因为它通常含有许多可以使用的统计资料。但是，如果你不需要做任何事情，而不是做一个分裂，那么执行或逃避规则是一个更好的选择。

你也可以试试这个

1
2
3
 String concatenated_String="hi^Hello";

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

Use org.apache.commons.lang.stringutilis split method which can split strings based on the character or string you want to split.

方法签名：

ZZU1

在你的案件中，你想在有"-"的时候划破一条弦。

你可以简单地说：

1
2
3
String str ="004-034556";

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

输出

1
2
004
034556

假设你的弦乐不存在，它会回归纪梵弦乐，而你不会有任何例外。

对于简单的使用案例，应该做这份工作。如果你使用瓜娃，还有一个分割级，它允许不同的弦乐操作和支持者的魅力：

1
2
3
4
Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);

使用REGEX的弦分裂多个字符

1
2
3
4
5
6
7
8
9
10
11
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]);
        }
     }
  }

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

但不要期望所有JDK版本的相同输出。我看到一个在JDK版本中存在的错误，第一个字符串被忽略了。这个错误不在最新的JDK版本，但它存在于JDK 1.7晚版本和1.8早版本之间。

消耗最少资源的最快方法可能是：

1
2
3
4
5
6
7
8
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 '-'
}
相关讨论

总结：在Java中至少有五种方法来分割字符串：

  • String()：

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

  • pattern.compile(regexp).splitasstream(输入)：

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

  • StringTokenizer(遗留类)：

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

  • google guava拆分器：

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

  • Apache Commons字符串实用程序：

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

    • 因此，您可以根据需要选择最佳选项，例如返回类型(数组、列表或iterable)。

    下面是这些方法和最常见的示例(如何按点、斜线、问号等拆分)的大概述。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    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);
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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
    2
    3
    String textStr[] = yourString.split("\
    ?\
    "    );

    你可以用以下声明划分一条弦：

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

    你可以使用分解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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];
        }
    }

    Else你可以用弦乐机

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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("-");
        }
    }

    这样做的一个方法是在一个环路中运行，并使用所需的分割特性。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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);
        }
    }

    输出

    1
    2
    3
    The split parts of the String are:
    004
    034556

    请不要使用弦乐类，因为它是一种遗留的等级，是为了兼容性的原因，它的使用在新的代码中是讨论的。我们可以按照其他人的建议使用分裂方法。

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

    And as expected it will print:

    1
    [004, 034556]

    在回答这个问题时，我还想做一个改变，这一改变是在日本第八大学为split制定的。分割方法使用Pattern.split的弦，现在它将在结果阵列的起始位置上消除间隙弦。Notice this change in documentation for Java 8:

    BLCK1/

    It means for the following example:

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

    我们将获得三条弦乐：[0, 0, 4]，而不是像Java 7和之前那样的四条弦乐。也检查这个类似的问题。

    这里有两条路可以实现。

    方式1：当你需要用一个特殊字符分割两个号码时，你可以使用规则

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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());
            }
        }
    }

    方法2：使用弦分割法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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);
            }
        }
    }
    相关讨论

    如果有任何类型的定义，你可以简单地使用弦乐器在两个或更多部分中划分一条弦乐：

    1
    2
    3
    4
    5
    StringTokenizer st = new StringTokenizer("004-034556","-");
    while(st.hasMoreTokens())
    {
        System.out.println(st.nextToken());
    }
    1
    2
    3
    4
    5
    String str="004-034556"
    String[] sTemp=str.split("-");// '-' is a delimiter

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

    雅瓦多克等级中的方法

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

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

    这里有很多分裂弦的例子，但我的小码优化了。

    只有两种方法你真的需要考虑。

    如果只有一个字符，或者您不关心性能，请使用string.split

    如果性能不是问题，或者交货单是一个非正则表达式特殊字符的单个字符(即，不是.$|()[{^?*+\中的一个)，则可以使用String.split。

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

    如果分隔符是单个字符而不在上面的列表中，则拆分方法有一个优化，以避免使用正则表达式。否则，它必须编译一个正则表达式，这是不理想的。

    使用pattern.split并预编译模式(如果使用复杂的delimeter并且您关心性能)

    如果性能是一个问题，而您的交货期不是上面提到的其中一个问题，那么您应该预先编译一个正则表达式模式，然后重新使用它。

    1
    2
    3
    4
    5
    // Save this somewhere
    Pattern pattern = Pattern.compile("[,;:]");

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

    最后一个选项仍然创建一个新的Matcher对象。您还可以缓存这个对象，并为每个输入重置它以获得最大的性能，但是这会稍微复杂一些，而且不安全。

    您可以使用方法split

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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 "-".");
            }

        }
    }

    我只想编写一个算法，而不是使用Java内置函数：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    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;
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    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));
        }
    }

    As mentioned by everyone, split() is the best option which may be used in your case. An alternative method can be using substring().

    分裂一条弦，使用String.split(regex)

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

    输出

    1
    2
    004
    034556

    要拆分字符串，请使用string.split(regex)。查看以下示例：

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

    产量

    1
    2
    004
    034556

    注释此拆分(regex)将regex作为参数，请记住转义regex特殊字符，如句点/点。

    From the documentation：

    public String[] split(String regex,int limit) Splits this string around matches of the given regular expression. The array returned by this method contains each
    substring of this string that is terminated by another substring that
    matches the given expression or is terminated by the end of the
    string. The substrings in the array are in the order in which they
    occur in this string. If the expression does not match any part of the
    input then the resulting array has just one element, namely this
    string.

    基本上，你可以做这样的事情：

    1
    2
    3
    4
    5
    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);
    }

    输出

    1
    2
    3
    4
    123
    456
    789
    123
    1
    2
     String string ="004^034556-34";
     String[] parts = string.split(Pattern.quote("^"));

    如果你有一个特殊的特征，那么你可以使用它。如果你有Dash(-)那么你可以缩短代码：

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

    如果你尝试在Dash(^)位置添加其他特殊字符，那么错误就会产生阵列输出性感受。因为你必须使用EDOCX1

    相关讨论

    有时，如果你想拆分string containing +，那么它就不会拆分；相反，你会得到runtime error。在这种情况下，首先是replace + to _，然后分割：

    1
    2
     this.text=text.replace("/","_");
                String temp[]=text.split("_");
    相关讨论