如何在Java中拆分字符串

我有一个字符串，

“004-034556”

，我想将其拆分为两个字符串：

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

---

这意味着第一个字符串将包含

'-'

之前的字符，第二个字符串将包含

'-'

之后的字符。我还想检查字符串中是否有

'-'

。如果没有，我将抛出一个异常。我如何才能做到这一点？

只需使用适当的方法：

请注意，这需要一段时间，因此请记住在必要时退出

是12个具有特殊含义的字符：反斜杠

\

、插入符号

^

、美元符号

$

、句号或点

、竖条或管道符号

、问号

？

、星号或星号

*

、加号

+

、括号

（

、右括号

）

、左方括号

[

、左大括号

{

，这些特殊字符通常称为“元字符”

因此，如果要在例如句点/dot

上拆分，在正则表达式中表示“”，请使用转义单个特殊字符，如So

split（\\”

），或使用表示文字字符，如So

split（[.]”

），或使用转义整个字符串，如So

split（Pattern.quote（“.”）

要预先测试字符串是否包含某些字符，只需使用

注意，这不需要正则表达式。为此，请使用

---

如果要在结果部分中保留拆分字符，请使用。如果希望拆分字符最终位于左侧，请通过前缀

？使用正向查找，只需使用适当的方法：

请注意，这需要一段时间，因此请记住在必要时退出

是12个具有特殊含义的字符：反斜杠
\
、插入符号
^
、美元符号
$
、句号或点
、竖条或管道符号
、问号
？
、星号或星号
*
、加号
+
、括号
（
、右括号
）
、左方括号
[
、左大括号
{
，这些特殊字符通常称为“元字符”

因此，如果要在例如句点/dot
上拆分，在正则表达式中表示“”，请使用转义单个特殊字符，如So
split（\\”
），或使用表示文字字符，如So
split（[.]”
），或使用转义整个字符串，如So
split（Pattern.quote（“.”）

要预先测试字符串是否包含某些字符，只需使用

注意，这不需要正则表达式。为此，请使用

如果要在结果部分中保留拆分字符，请使用。如果希望拆分字符在左侧结束，请通过前缀
？使用正向查找：

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

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

检查
字符串中的方法。
使用：

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

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

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

检查
字符串中的方法

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

应该做你想做的事情。string类有很多方法可以使用string进行操作

应该做你想做的事情。string类有很多方法可以使用string进行操作。
这些要求为解释留下了空间。我建议编写一个方法

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”
可以在
[333333333-33]或[333-333,33]
中分开吗？或者它是一个错误吗？等等。
这些要求留下了解释的余地。我建议写一个方法

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”
可以在
[333333333-33]或[333-333,33]中分开吗
或者它是一个错误？等等。
直接处理字符串的替代方法是使用带有捕获组的正则表达式。这样做的优点是，它可以直接暗示对输入的更复杂的约束。例如，下面将字符串分成两部分，并确保两部分都符合仅支持数字：

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

由于模式在这个实例中是固定的，所以可以预先编译它并将其存储为静态成员（在示例中是在类加载时初始化的）
String[] out = string.split("-");

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

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

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+)

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

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

 String concatenated_String="hi^Hello";

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

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

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

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

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

String str = "004-034556";

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

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

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

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(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

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

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

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

[004, 034556]

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

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

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

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

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

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

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

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

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

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

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

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

004
034556

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

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

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

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

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

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

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

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

004
034556

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

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

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

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