提问



我有一个字符串,"004-034556",我想分成两个字符串:


string1=004
string2=034556


这意味着第一个字符串将包含'-'之前的字符,第二个字符串将包含'-'之后的字符。我还想检查字符串中是否有'-'。如果没有,我会抛出异常。我怎样才能做到这一点?

最佳参考


只需使用适当的方法:String#split()[105]


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


请注意,这需要一个正则表达式,所以请记住在必要时转义特殊字符。[106] [107]



  有12个特殊含义的字符:反斜杠\,插入符号^,美元符号$,句点或点.,垂直条或管道符号[[|,问号?,星号或星号*,加号+,左括号(,右括号) ,以及开口方括号[,开口大括号{,这些特殊字符通常称为元字符。[108]



所以,如果你想拆分,例如句点/点.表示正则表达式中的任何字符,使用反斜杠\来转义单个特殊字符,如split("\\."),或使用字符类[]来表示像split("[.]")这样的文字字符,或者使用Pattern#quote()来逃避整个字符串split(Pattern.quote("."))[109] [110] [111] [112]


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


要事先测试字符串是否包含某些字符,只需使用String#contains()[113]


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


注意,这不需要正则表达式。为此,请改用String#matches()[114]


如果你想在结果部分中保留分裂字符,那么请使用正面的外观。如果你想让分裂字符最后在左边,通过前缀?<=组使用正向后观关于模式。[115]


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


如果您希望将拆分字符放在右侧,请在模式上使用前缀?=组来使用正向前瞻。


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


如果您想限制结果零件的数量,那么您可以提供所需的数字作为split()方法的第二个参数。


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

其它参考1


直接处理字符串的替代方法是使用带捕获组的正则表达式。这样做的优点是可以直接表示对输入的更复杂的约束。例如,以下内容将字符串拆分为两部分,并确保两者都只包含数字:


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


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


(\d+)-(\d+)


括号表示捕获组;匹配该部分正则表达式的字符串可以通过Match.group()方法访问,如图所示。 \\ d匹配单个十进制数字,+表示匹配前一个表达式中的一个或多个。 - 没有特殊含义,所以只需匹配输入中的那个字符。注意你需要双重转义反斜杠将其写为Java字符串时。其他一些例子:


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

其它参考2


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-[116]


其它参考3


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

其它参考4


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


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

其它参考5


这些要求留有了解释空间。我建议写一个方法,


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


它封装了这个功能。当然,您可以使用String.split(..),如实现的其他答案中所述。


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


优秀考生应包括:


 - "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]中分开,还是错误?等等。

其它参考6


假如说



  • 你真的不需要正确的分词表达式

  • 你碰巧已经在app中使用了apache commons lang



最简单的方法是使用StringUtils#split(java.lang.String,char)。如果你不需要正则表达式,这比开箱即用的Java更方便。就像它的手册所说,它的工作原理如下:[117]


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"]


我建议使用commong-lang,因为它通常包含许多可用的东西。但是,如果除了进行拆分之外你不需要它,那么实现自己或逃避正则表达式是一个更好的选择。

其它参考7


使用org.apache.commons.lang.StringUtilssplit方法,它可以根据你想要拆分的字符或字符串拆分字符串。[118]


方法签名:


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


在您的情况下,您希望在存在 - 时拆分字符串。


你可以简单地做如下:


String str = "004-034556";

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


输出:


004
034556


假设如果你的字符串中不存在-,它将返回给定的字符串,并且你不会得到任何异常。

其它参考8


你也可以这样试试


 String concatenated_String="hi^Hello";

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

其它参考9


使用Java 8:


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

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

其它参考10


字符串使用正则表达式分割多个字符


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


输出:


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早期版本之间存在某些版本。[119]

其它参考11


对于简单的用例String.split()应该做的工作。如果你使用guava,还有一个Splitter类,它允许链接不同的字符串操作并支持CharMatcher:[120] [121] [122]


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

其它参考12


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

其它参考13


您可以使用以下语句通过换行符拆分字符串:


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


您可以使用以下语句通过连字符/字符拆分字符串:


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

其它参考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]);
    }
  }
}

其它参考15


最快的方式,也消耗最少的资源可能是:


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

其它参考16


一种方法是在for-each循环中运行String并使用所需的拆分字符。


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


输出:


The split parts of the String are:
004
034556

其它参考17


请不要使用StringTokenizer类,因为它是由于兼容性原因而保留的遗留类,并且在新代码中不鼓励使用它。我们也可以使用其他人建议的分割方法。[123]


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


正如预期的那样,它将打印:


[004, 034556]


在这个答案中,我还想指出 Java 8中split方法发生的一个变化。 String#split()方法使用Pattern.split,现在它将在结果数组的开头删除空字符串。请注意Java 8文档中的这一更改:[124] [125]



  在输入开头有正宽度匹配时
  序列然后在开头包含一个空的前导子字符串
  得到的数组。但是,开头的零宽度匹配
  永远不会产生这样空的前导子串。



它意味着以下示例:


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


我们将得到三个字符串:[0, 0, 4]而不是Java 7及之前的情况。还要检查这个类似的问题。

其它参考18


你可以使用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];
    }
}


否则,您可以使用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("-");
    }
}

其它参考19


以下两种方式实现它。


方法1:由于你必须用特殊字符分割两个数字,你可以使用正则表达式


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:使用字符串拆分方法


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

其它参考20


无论是否有任何类型的分隔符,您都可以使用StringTokenizer将字符串拆分为两个或多个部分:


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

其它参考21


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



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



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


这里有很多分裂字符串的例子,但我的代码经过优化。

其它参考22


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

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

其它参考23


总结一下:至少有五种方法可以在Java中拆分字符串:



  1. String.split():


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

  2. Pattern.compile(正则表达式).splitAsStream(输入):


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

  3. StringTokenizer(遗留类):


    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. Apache Commons StringUtils:


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



因此,您可以根据需要为您选择最佳选择,例如:返回类型(数组,列表或可迭代)。


以下是这些方法的大概述和最常见的例子(如何用点,斜线,问号等分割)[128]

其它参考24


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



  正如大家所提到的,split()是可以在你的情况下使用的最佳选择。另一种方法可以使用substring()。


其它参考25


要拆分字符串,请使用String.split(regex):


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


输出:


004
034556

其它参考26


我只是想编写一个算法而不是使用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;
}

其它参考27


要拆分字符串,请使用String.split(regex)。查看以下示例:


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


产量


004
034556


注意
这个分割(正则表达式)将正则表达式作为参数,记住要转义正则表达式特殊字符,如句点/点。

其它参考28


从文档:



  public String[] split(String regex,int limit) 围绕给定正则表达式 的匹配拆分此字符串。此方法返回的数组包含每个数组
  此字符串的子字符串由另一个子字符串终止
  匹配给定的表达式或终止于
  串。数组中的子字符串位于 顺序
  发生在这个字符串中。如果表达式匹配的任何部分
  输入然后生成的数组只有一个元素即此
  字符串。




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


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


输出:


123
456
789
123

其它参考29


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


如果你有一个特殊字符,那么你可以使用Patter.quote。如果您只是短划线( - ),那么您可以缩短代码:


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


如果您尝试添加其他特殊字符代替短划线(^),则错误将生成 ArrayIndexOutOfBoundsException 。为此你必须使用Pattern.quote