如何在Java中拆分字符串
我有一个字符串,如何在Java中拆分字符串,java,string,split,Java,String,Split,我有一个字符串,“004-034556”,我想将其拆分为两个字符串: string1="004"; string2="034556"; 这意味着第一个字符串将包含'-'之前的字符,第二个字符串将包含'-'之后的字符。我还想检查字符串中是否有'-'。如果没有,我将抛出一个异常。我如何才能做到这一点?只需使用适当的方法: 请注意,这需要一段时间,因此请记住在必要时退出 是12个具有特殊含义的字符:反斜杠\、插入符号^、美元符号$、句号或点、竖条或管道符号、问号?、星号或星号*、加号+、括号(、右括
“004-034556”
,我想将其拆分为两个字符串:
string1="004";
string2="034556";
这意味着第一个字符串将包含
'-'
之前的字符,第二个字符串将包含'-'
之后的字符。我还想检查字符串中是否有'-'
。如果没有,我将抛出一个异常。我如何才能做到这一点?只需使用适当的方法:
请注意,这需要一段时间,因此请记住在必要时退出
是12个具有特殊含义的字符:反斜杠\
、插入符号^
、美元符号$
、句号或点
、竖条或管道符号
、问号?
、星号或星号*
、加号+
、括号(
、右括号)
、左方括号[
、左大括号{
,这些特殊字符通常称为“元字符”
因此,如果要在例如句点/dot
上拆分,在正则表达式中表示“”,请使用转义单个特殊字符,如Sosplit(\\”
),或使用表示文字字符,如Sosplit([.]”
),或使用转义整个字符串,如Sosplit(Pattern.quote(“.”)
要预先测试字符串是否包含某些字符,只需使用
注意,这不需要正则表达式。为此,请使用
如果要在结果部分中保留拆分字符,请使用。如果希望拆分字符在左侧结束,请通过前缀?使用正向查找:
这将把字符串分成两部分。数组中的第一个元素将是包含-
之前的内容的部分,数组中的第二个元素将包含-
之后的字符串部分
如果数组长度不是2,则字符串的格式不是:string-string
检查字符串中的方法
String[] out = string.split("-");
应该做你想做的事情。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]中分开吗
或者它是一个错误?等等。直接处理字符串的替代方法是使用带有捕获组的正则表达式。这样做的优点是,它可以直接暗示对输入的更复杂的约束。例如,下面将字符串分成两部分,并确保两部分都符合仅支持数字:
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+)
括号表示捕获组;与regexp的该部分匹配的字符串可以通过Match.group()方法访问,如图所示。\d与单个十进制数字匹配,+表示“匹配前面的一个或多个表达式”).The-没有特殊含义,因此只需匹配输入中的该字符。请注意,在将其作为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
String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);
//这使得正则表达式问题不成问题
//但我们必须记住,分隔符字符串中的每个字符都会被处理
//就像一个分隔符
公共静态字符串[]SplitUsingTokenizer(字符串主题、字符串分隔符){
StringTokenizer strTkn=新的StringTokenizer(主题,分隔符);
ArrayList arrLis=新的ArrayList(subject.length());
while(strtn.hasMoreTokens())
arrLis.add(strTkn.nextToken());
返回arrLis.toArray(新字符串[0]);
}
您也可以这样尝试
String concatenated_String="hi^Hello";
String split_string_array[]=concatenated_String.split("\\^");
公共类拆分测试{
公共静态字符串[]拆分(字符串文本、字符串分隔符){
java.util.List parts=new java.util.ArrayList();
text+=分隔符;
for(int i=text.indexOf(分隔符),j=0;i!=-1;){
字符串温度=文本子字符串(j,i);
如果(温度修剪()长度()!=0){
零件。添加(温度);
}
j=i+分隔符.length();
i=text.indexOf(分隔符,j);
}
返回parts.toArray(新字符串[0]);
}
公共静态void main(字符串[]args){
字符串str=“004-034556”;
字符串分隔符=“-”;
字符串结果[]=split(str,分隔符);
for(字符串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
最简单的方法是使用。如果您不需要正则表达式,这比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,因为它通常包含很多有用的东西。但是,如果您除了执行拆分之外不需要它,那么实现自己或转义正则表达式是更好的选择。使用拆分方法,可以根据要拆分的字符或字符串拆分字符串
方法签名:
public static String[] split(String str, char separatorChar);
在
(\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 \"-\".");
}
}
}