如何在Java中拆分字符串？

使用适当命名的方法#0。

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

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

^2是12个具有特殊含义的字符：反斜杠\、插入符号^、美元符号$、句点或圆点.、竖线或圆管符号|、问号?、星号或星号*、加号+、开括号(、闭括号)、以及开头方括号^0、开头花括号^1，这些特殊字符通常被称为“元字符”。

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

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

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

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

注意，这不接受正则表达式。为此，请改用#0。

如果您想在结果部分中保留拆分字符，请使用正面观察。如果您想让拆分字符在左侧结束，请通过在模式上添加?<=组前缀来使用积极的lookback。

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]; // 004String part2 = parts[1]; // -034556

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

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

用途：

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

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

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

查看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"

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

例如，如果"-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("\\^");

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

 this.text=text.replace("/", "_");String temp[]=text.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#拆分（java.lang.String， char）。如果你不需要正则表达式，这比Java提供的更方便。就像它的手册所说，它的工作原理如下：

A null input String returns null.
StringUtils.split(null, *)         = nullStringUtils.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"]

我建议使用comong-lang，因为它通常包含很多可用的东西。但是，如果您除了进行拆分之外不需要它，那么实现自己或转义正则表达式是更好的选择。

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

方法签名：

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

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

你可以简单地做如下：

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

输出：

004034556

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

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

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

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

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

对于简单的用例，#0应该可以完成这项工作。如果您使用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:004034556

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

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:17Str[0]:Str[1]:StringStr[2]: StringStr[3]: StringStr[4]: StringStr[5]: StringStr[6]: StringStr[7]:Str[8]:StringStr[9]:StringStr[10]: StringStr[11]: StringStr[12]:Str[13]:StringStr[14]:StringStr[15]:StringStr[16]:String

但是不要期望所有JDK版本都有相同的输出。我看到一个bug存在于某些JDK版本中，其中第一个空字符串被忽略。这种bug在最新的JDK版本中不存在，但它存在于JDK 1.7后期版本和1.8早期版本之间的某些版本中。

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

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

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

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

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

[004, 034556]

在这个答案中，我还想指出#0方法在Java8中发生了一个变化。字符串#拆分（）方法使用了Pattern.split，现在它将删除结果数组开头的空字符串。请注意Java8留档中的改变：

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

这意味着以下示例：

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

我们将得到三个字符串：[0, 0, 4]，而不是Java7和之前的四个。

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

Java8：

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

正如每个人都提到的，分裂（）是您的情况下可能使用的最佳选择。另一种方法可以使用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]);

输出：

004034556

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

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

从留档：

public String[] split(String regex,int limit)将此字符串拆分为给定正则表达式的匹配项。此方法返回的数组包含每个这个字符串的子字符串被另一个子串终止匹配给定的表达式或由字符串。数组中的子字符串位于它们所在的订单中发生在此字符串中。如果表达式不要匹配输入，则结果数组只有一个元素，即this字符串。

基本上你可以这样做：

String s = "123-456-789-123"; // The String to be splitString[] array = s.split("-"); // Split according to the hyphen and put them in an arrayfor(String subString : array){ // Cycle through the arraySystem.out.println(subString);}

输出：

123456789123

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

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

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

如果您尝试添加其他特殊字符来代替破折号（^），那么错误将产生数组索引越界异常。为此，您必须使用Pattern.quote。

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

1. String.split：

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

2. Pattern.compile：

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

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

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

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

产出

004034556

备注：

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

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

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

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

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

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

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

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

// Save this somewherePattern pattern = Pattern.compile("[,;:]");
/// ... laterString[] 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。

然后我想简单地SetText（）三个不同的TextViews显示该字符串。

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

输出：

TnGeneralDOMESTIC

如果您正在验证字母数字，则将正则表达式更改为[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);

使用模式是java8下面的方式！

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