如何在Java中拆分字符串答案

【问题标题】：How to split a string in Java如何在Java中拆分字符串
【发布时间】：2011-03-29 18:02:11
【问题描述】：

我有一个字符串"004-034556"，我想将其拆分为两个字符串：

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

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

【问题讨论】：

标签： java string split

【解决方案1】：

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

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

请注意，这需要 regular expression，因此请记住在必要时转义 special characters。

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

所以，如果您想拆分，例如句点/点. 在正则表达式中表示“any character”，使用backslash \ 转义单个特殊字符，如split("\\.")，或使用character class [] 表示文字字符，如split("[.]") ，或使用Pattern#quote() 转义整个字符串，就像split(Pattern.quote(".")) 一样。

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

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

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

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

如果您想在结果部分中保留拆分字符，请使用positive lookaround。如果您希望拆分字符出现在左侧，请通过在模式上添加 ?<= 组前缀来使用正向向后查找。

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

【讨论】：

为什么要用井号来分隔String的方法？
@Crowie: javadoc-style.
极端情况：如果找不到reugalr expression，则返回一个包含整个字符串的元素数组。
不敢相信投票最多的版本是这样的。 1）如果原始字符串包含两个“-”，则第 2 部分不是发帖人想要的 2）没有问题中提到的错误处理。 3）效率低。单个字符搜索需要正则表达式构造和匹配。创建了额外的数组，等等。
@David：1）问题没有涉及。 2）它不会抛出异常。 3）OP询问如何拆分，而不是如何子串。 4）休息一下，深呼吸，把所有的负面情绪都扔掉:)

【解决方案2】：

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

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

【讨论】：

这是一个很好的解决方案，但是第一部分应该是m.group(1)，第二部分应该是m.group(2)，因为m.group(0) 实际上返回了完整的匹配模式。我想我还记得 group(0) 曾经是第一个匹配而不是完整模式，也许这在最近的 Java 版本更新中发生了变化。

【解决方案3】：

用途：

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

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

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

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

【讨论】：

这将接受“-555”作为输入并返回 [, 555]。如果接受这一点是有效的，这些要求并没有明确定义。我建议编写一些单元测试来定义所需的行为。
将 (result.length != 2) 更改为 (result.length

【解决方案4】：

这个：

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

应该做你想做的事。 string 类有很多方法可以对字符串进行操作。

【讨论】：

【解决方案5】：

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

【讨论】：

JavaDoc 明确指出："StringTokenizer 是一个遗留类，出于兼容性原因保留，尽管不鼓励在新代码中使用它。建议任何寻求此功能的人都使用String 的split 方法或java.util.regex 包。"

【解决方案6】：

使用 Java 8：

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

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

【讨论】：

如果要删除空格，请在 split 之后添加 .map(String::trim)

【解决方案7】：

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

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] 中分开还是错误？以此类推。

【讨论】：

有用的建议，但实际上并不是问题的答案。如果您支持其他答案的详细信息，则首选评论。
使用：拆分（字符串正则表达式，int limit）和不拆分（字符串正则表达式）供参考访问geeksforgeeks.org/split-string-java-examples

【解决方案8】：

你也可以这样试试

 String concatenated_String="hi^Hello";

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

【讨论】：

【解决方案9】：

假设，那

您的拆分实际上并不需要正则表达式
你碰巧已经在你的应用中使用了 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，因为它通常包含很多可用的东西。但是，如果除了拆分之外您不需要它，那么实现自己或转义正则表达式是一个更好的选择。

【讨论】：

【解决方案10】：

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

方法签名：

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

在您的情况下，您希望在有“-”时拆分字符串。

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

String str = "004-034556";

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

输出：

004
034556

假设如果你的字符串中不存在-，则返回给定的字符串，你不会得到任何异常。

【讨论】：

【解决方案11】：

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

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

【讨论】：

【解决方案12】：

总结一下：在Java中拆分字符串至少有五种方式：

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

Pattern.compile(regexp).splitAsStream(input)：

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

StringTokenizer（遗留类）：

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

Apache Commons StringUtils：

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

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

Here是对这些方法和最常见示例的大概述（如何按点、斜线、问号等分割）

【讨论】：

【解决方案13】：

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

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

【讨论】：

最稀缺的资源往往是程序员的时间和注意力。这段代码比其他代码消耗更多的资源。
你有很多可以使用的内置资源，在真正考虑性能的地方，这个解决方案缺乏性能执行时间
通过错误检查对单个字符进行简单拆分，这并不比正则表达式版本复杂。
太棒了！最后一个不使用正则表达式的问题的答案！使用正则表达式来完成这个简单的任务相当令人头疼。很高兴看到地球上还有理智的程序员:-)
只有一个“-”，需要一个异常，结果应该转到 string1 和 string2。 将 string1 = s.substring(0, s.indexOf("-")); string2 = s.substring(s.indexOf("-") + 1); 去掉。如果没有“-”，您将自动获得StringIndexOutOfBoundsException。

【解决方案14】：

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

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 版本都具有相同的输出。我已经看到 one bug 存在于某些 JDK 版本中，其中第一个空字符串已被忽略。这个bug在最新的JDK版本中不存在，但是在JDK 1.7后期版本和1.8早期版本之间的一些版本中存在。

【讨论】：

【解决方案15】：

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

【讨论】：

【解决方案16】：

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

使用 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 对象。您还可以缓存此对象并为每个输入重置它以获得最佳性能，但这有点复杂并且不是线程安全的。

【讨论】：

【解决方案17】：

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

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

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

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

【讨论】：

【解决方案18】：

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

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

正如预期的那样，它会打印出来：

[004, 034556]

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

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

对于下面的例子来说意味着：

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

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

【讨论】：

【解决方案19】：

一种方法是在 for-each 循环中遍历字符串并使用所需的拆分字符。

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

【讨论】：

【解决方案20】：

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

【讨论】：

如果我可以分享建议，您的回答如何比已经接受的解决方案带来更多价值？ stackoverflow.com/a/3481842/420096 在这种情况下，您可以对现有解决方案投票，特别是如果这是一个明显的微不足道的案例。

【解决方案21】：

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

【讨论】：

【解决方案22】：

这里有两种实现方式。

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

【讨论】：

【解决方案23】：

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

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

【讨论】：

【解决方案24】：

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

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

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

【讨论】：

用|替换-看看会发生什么:)
在这种情况下，请检查stackoverflow.com/questions/10796160/…

【解决方案25】：

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

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

【讨论】：

【解决方案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】：

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

【讨论】：

【解决方案28】：

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()。

【讨论】：

【解决方案29】：

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

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

输出：

004
034556

【讨论】：

【解决方案30】：

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

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

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

如果您尝试添加其他特殊字符代替破折号(^)，则错误将生成ArrayIndexOutOfBoundsException。为此，您必须使用Pattern.quote。

【讨论】：