只需使用适当命名的方法:String#split()
。
String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556
请注意,这需要一个 regular expression,因此请记住在必要时转义 special characters。
有 12 个具有特殊含义的字符:反斜杠 \、插入符号 ^、美元符号 $、句点或点 .、竖线或管道符号 |、问号 ?、星号或星号 *、加号 + , 左括号 (, 右括号 ) 和左方括号 [, 左大括号 {, 这些特殊字符通常称为“元字符”。
因此,如果您想在例如句点/点 .
上拆分,这在正则表达式中表示“any character”,请使用 backslash \
来转义单个特殊字符,如 split("\\.")
,或使用 character class []
来表示文字字符如 split("[.]")
,或使用 Pattern#quote()
转义整个字符串,如 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()
。
如果您想在结果部分中保留拆分字符,请使用 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
直接处理字符串的另一种方法是将正则表达式与捕获组一起使用。这样做的好处是可以直接在输入上暗示更复杂的约束。例如,以下将字符串分成两部分,并确保两者都仅包含数字:
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 版本更新中发生了变化。
利用:
String[] result = yourString.split("-");
if (result.length != 2)
throw new IllegalArgumentException("String not in correct format");
这会将您的字符串分成两部分。数组中的第一个元素将是包含 -
之前的内容的部分,数组中的第二个元素将包含 -
之后的字符串部分。
如果数组长度不是 2,则字符串不是格式:string-string
。
查看 String
类中的 split() 方法。
这个:
String[] out = string.split("-");
应该做你想做的事。字符串类有很多方法来操作字符串。
// 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]);
}
StringTokenizer
是一个遗留类,出于兼容性原因保留,尽管不鼓励在新代码中使用它。建议任何寻求此功能的人使用 {2 String
或 java.util.regex
包的 } 方法。”
使用 Java 8:
List<String> stringList = Pattern.compile("-")
.splitAsStream("004-034556")
.collect(Collectors.toList());
stringList.forEach(s -> System.out.println(s));
split
之后添加 .map(String::trim)
这些要求留有解释的余地。我建议写一个方法,
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]
中分开还是错误?等等。
使用 org.apache.commons.lang.StringUtils' 拆分方法,可以根据要拆分的字符或字符串拆分字符串。
方法签名:
public static String[] split(String str, char separatorChar);
在您的情况下,您希望在有“-”时拆分字符串。
您可以简单地执行以下操作:
String str = "004-034556";
String split[] = StringUtils.split(str,"-");
输出:
004
034556
假设如果您的字符串中不存在 -
,它会返回给定的字符串,并且您不会得到任何异常。
你也可以这样试试
String concatenated_String="hi^Hello";
String split_string_array[]=concatenated_String.split("\\^");
假如说
你真的不需要正则表达式来分割
你碰巧已经在你的应用程序中使用了 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,因为它通常包含很多可用的东西。但是,如果除了拆分之外您不需要它,那么实现自己或转义正则表达式是一个更好的选择。
对于简单的用例,String.split()
应该可以完成这项工作。如果您使用 guava,还有一个 Splitter 类允许链接不同的字符串操作并支持 CharMatcher:
Splitter.on('-')
.trimResults()
.omitEmptyStrings()
.split(string);
总结一下:在Java中拆分字符串至少有五种方法:
String.split(): String[] 部分="10,20".split(","); Pattern.compile(regexp).splitAsStream(input): List
因此,您可以根据需要选择最适合您的选项,例如返回类型(数组、列表或可迭代)。
Here 是对这些方法和最常见示例(如何按点、斜线、问号等进行分割)的全面概述
最快的方法,也消耗最少的资源可能是:
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 = s.substring(0, s.indexOf("-"));
string2 = s.substring(s.indexOf("-") + 1);
。如果没有“-”,您将自动获得 StringIndexOutOfBoundsException
。
使用正则表达式拆分多个字符的字符串
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早期版本之间的一些版本中存在。
您真正需要考虑的只有两种方法。
使用 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
对象。您还可以缓存此对象并为每个输入重置它以获得最佳性能,但这有点复杂并且不是线程安全的。
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 textStr[] = yourString.split("\\r?\\n");
您可以使用以下语句通过连字符/字符拆分字符串:
String textStr[] = yourString.split("-");
请不要使用 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。
一种方法是在 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
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]);
}
}
}
您可以使用拆分():
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("-");
}
}
这里有两种实现方式。
方式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);
}
}
}
无论是否有任何类型的分隔符,您都可以简单地使用 StringTokenizer 将字符串拆分为两个或多个部分:
StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
System.out.println(st.nextToken());
}
查看 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++;
}
这里有很多拆分字符串的例子,但我很少优化代码。
-
替换为 |
看看会发生什么 :)
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter
string1=004 // sTemp[0];
string2=034556//sTemp[1];
我只是想编写一个算法而不是使用 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;
}
您可以使用方法 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 \"-\".");
}
}
}
要拆分字符串,请使用 String.split(regex)。查看以下示例:
String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);
输出
004
034556
笔记:
此拆分(正则表达式)将正则表达式作为参数。请记住转义正则表达式特殊字符,例如句点/点。
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
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()。
不定期副业成功案例分享
reugalr expression
,则返回一个包含整个字符串的元素数组。