如何在 Java 中拆分字符串？

使用适当命名的方法 String#split（）。

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

请注意，假定 的参数是正则表达式，因此请记住在必要时对特殊字符进行转义。split

有12个具有特殊含义的字符：反斜杠、插入符号、美元符号、句点或点、竖条或竖线符号、问号、星号或星号、加号、左括号、右括号、左方括号、左大括号，这些特殊字符通常被称为“元字符”。\^$.|?*+()[{

例如，要拆分句点/点（在正则表达式中表示“任何字符”），请使用反斜杠 \ 来转义单个特殊字符，例如 so ，或者使用字符类 [] 来表示文字字符，例如 so ，或者使用 Pattern#quote（） 来转义整个字符串，例如 so 。.split("\\.")split("[.]")split(Pattern.quote("."))

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

要事先测试字符串是否包含某些字符，只需使用 String#contains（）。

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

请注意，这不采用正则表达式。为此，请改用 String#matches（）。

如果您想在生成的部分中保留拆分字符，请使用积极的环视。如果您想让拆分字符以左侧结束，请在图案上添加前缀 group 来使用正后视。?<=

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

如果您希望拆分字符以右侧结束，请在图案上添加前缀 group 来使用正面展望。?=

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

用：

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

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

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

查看类中的 split（） 方法。String

这：

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

应该做你想做的事。字符串类有许多处理字符串的方法。

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

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

封装此函数。当然，您可以使用 String.split（..），如实现的其他答案中所述。

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

优秀的考生应包括：

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

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

例如，if should return in 或者 if it is an error。 可以分开还是错误？等等。"-333"[,333]"333-333-33"[333,333-33] or [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");
    }
}

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

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

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

假设

• 你真的不需要正则表达式来进行拆分
• 您碰巧已经在您的应用程序中使用了 Apache Commons Lang

最简单的方法是使用 StringUtils#split（java.lang.String， char）。如果您不需要正则表达式，这比 Java 开箱即用提供的更方便。就像它的手册说的那样，它的工作原理是这样的：

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，因为通常它包含很多可用的东西。但是，如果您除了进行拆分之外不需要它，那么实现自己或转义正则表达式是更好的选择。

使用 org.apache.commons.lang.StringUtils 的 split 方法，它可以根据要拆分的字符或字符串拆分字符串。

方法签名：

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

在您的例子中，您希望在存在“-”时拆分字符串。

您可以简单地执行以下操作：

String str = "004-034556";

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

输出：

004
034556

假设如果字符串中不存在，则返回给定的字符串，并且不会出现任何异常。-

可以使用以下语句按换行符拆分字符串：

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

您可以使用以下语句按连字符/字符拆分字符串：

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

对于简单的用例，String.split（） 应该可以完成这项工作。如果你使用 guava，还有一个 Splitter 类，它允许链接不同的字符串操作并支持 CharMatcher：

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

一种方法是在 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

使用正则表达式拆分包含多个字符的字符串

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 早期版本之间的某些版本中。

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

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

这里有很多拆分字符串的例子，但我的代码很少优化。

请不要使用 StringTokenizer 类，因为它是出于兼容性原因而保留的旧类，不建议在新代码中使用它。我们也可以按照其他人的建议使用拆分方法。

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

正如预期的那样，它将打印：

[004, 034556]

在这个答案中，我还想指出 Java 8 中 split 方法发生的一个变化。String#split（） 方法使用 ，现在它将删除结果数组开头的空字符串。请注意 Java 8 文档中的以下更改：Pattern.split

当输入开头有正宽度匹配时 序列，则在开头包含一个空的前导子字符串 的结果数组。然而，开始时的零宽度匹配 从不产生这种空的前导子字符串。

对于以下示例，这意味着：

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

我们将得到三个字符串：而不是像 Java 7 和之前那样的四个字符串。还要检查这个类似的问题。[0, 0, 4]

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

在 Java 8 中：

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

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

你可以使用 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("-");
    }
}

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（）。

这里有两种方法可以实现它。

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

要拆分字符串，请使用：String.split(regex)

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

输出：

004
034556

您可以简单地使用 StringTokenizer 将字符串拆分为两个或多个部分，无论是否有任何类型的分隔符：

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

从文档中：

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

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

如果您有特殊字符，则可以使用 Patter.quote。如果你只有破折号（-），那么你可以缩短代码：

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

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

总而言之：在 Java 中至少有五种方法可以拆分字符串：

1. 字符串.split（）：

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

2. Pattern.compile（regexp）.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. 谷歌番石榴拆分器：

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

5. Apache Commons StringUtils：

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

因此，您可以根据需要选择最适合您的选项，例如返回类型（数组、列表或可迭代）。

以下是这些方法和最常见的示例（如何按点、斜杠、问号等拆分）的大概述。

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

若要拆分字符串，请使用 String.split（regex）。查看以下示例：

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

输出

004
034556

注意：

此拆分 （regex） 将正则表达式作为参数。请记住转义正则表达式特殊字符，例如句点/点。

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

将 String.split 用于单字符分隔符，否则您不关心性能

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

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

split 方法进行了优化，以避免在分隔线是单个字符且不在上面列表中时使用正则表达式。否则，它必须编译一个正则表达式，这并不理想。

如果使用复杂的分隔符，请使用 Pattern.split 并预编译模式，并且您关心性能。

如果性能是一个问题，并且您的分隔符不是上述之一，则应预先编译一个正则表达式模式，然后可以重用该模式。

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

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

最后一个选项仍会创建一个新对象。您还可以缓存此对象并为每个输入重置它以获得最佳性能，但这有点复杂且不是线程安全的。Matcher

您可以使用以下方法：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 \"-\".");
        }
    }
}

我用了一根绳子，叫做，是这样的：“那些有硬币的人，在雨中享受，那些有纸币的人正忙着寻找庇护所”。stringValue

我将使用“，”作为冒号来拆分。stringValue

然后我只想使用三个不同 TextView 的 SetText（） 来显示该字符串。

String stringValue = "Those who had coins, enjoyed in the rain, those who had notes were busy looking for the shelter";
String ValueSplitByColon[] = stringValue.split(",");

String firstValue = ValueSplitByColon[0];
String secondValue = ValueSplitByColon[1];
String thirdValue = ValueSplitByColon[2];

txtV1.setText(firstValue);
txtV2.setText(secondValue;
txtV3.setText(thirdValue;

它给出的输出为：

1. txtV1 的值是：那些有硬币的人

2. txtV2值为：在雨中享受

3. txtV3 的值是：那些有笔记的人正忙着寻找避难所

我查看了所有答案，并注意到所有答案都是第三方许可或基于正则表达式的。

这是我使用的一个很好的哑实现：

/**
 * Separates a string into pieces using
 * case-sensitive-non-regex-char-separators.
 * <p>
 * &nbsp;&nbsp;<code>separate("12-34", '-') = "12", "34"</code><br>
 * &nbsp;&nbsp;<code>separate("a-b-", '-') = "a", "b", ""</code>
 * <p>
 * When the separator is the first character in the string, the first result is
 * an empty string. When the separator is the last character in the string the
 * last element will be an empty string. One separator after another in the
 * string will create an empty.
 * <p>
 * If no separators are set the source is returned.
 * <p>
 * This method is very fast, but it does not focus on memory-efficiency. The memory
 * consumption is approximately double the size of the string. This method is
 * thread-safe but not synchronized.
 *
 * @param source    The string to split, never <code>null</code>.
 * @param separator The character to use as splitting.
 * @return The mutable array of pieces.
 * @throws NullPointerException When the source or separators are <code>null</code>.
 */
public final static String[] separate(String source, char... separator) throws NullPointerException {
    String[] resultArray = {};
    boolean multiSeparators = separator.length > 1;
    if (!multiSeparators) {
        if (separator.length == 0) {
            return new String[] { source };
        }
    }
    int charIndex = source.length();
    int lastSeparator = source.length();
    while (charIndex-- > -1) {
        if (charIndex < 0 || (multiSeparators ? Arrays.binarySearch(separator, source.charAt(charIndex)) >= 0 : source.charAt(charIndex) == separator[0])) {
            String piece = source.substring(charIndex + 1, lastSeparator);
            lastSeparator = charIndex;
            String[] tmp = new String[resultArray.length + 1];
            System.arraycopy(resultArray, 0, tmp, 1, resultArray.length);
            tmp[0] = piece;
            resultArray = tmp;
        }
    }
    return resultArray;
}

String s = "TnGeneral|DOMESTIC";
String a[]=s.split("\\|");
System.out.println(a.toString());
System.out.println(a[0]);
System.out.println(a[1]);

输出：

TnGeneral
DOMESTIC

如果要验证字母数字，则将正则表达式更改为[A-Za-z0-9]+-[A-Za-z0-9]+

    public static final Pattern VALIDATE_PATTERN = Pattern.compile("[0-9]+-[0-9]+");

public static String[] validateString(String str) {
    if(VALIDATE_PATTERN.matcher(str).find()) {
        String[] output = str.split("-");
        if(output.length != 2) {
            throw new RuntimeException("Invalid string format");
        }
        return output;
    } else {
        throw new RuntimeException("Invalid string format");
    }
}

使用流拆分并打印字符串

String input = "004-034556";
Stream<String> stream = Arrays.stream(input.split( "-" ));
stream.forEach(System.out::println);

使用 Pattern 是 Java 8。下面是方法！！

package com.company;

import java.util.regex.Pattern;

public class umeshtest {

    public static void main(String a[]) {
        String ss = "I'm Testing and testing the new feature";
        Pattern.compile(" ").splitAsStream(ss).forEach(s -> System.out.println(s));
    }
}