如何在Java中分割字符串

我有一个字符串"004-034556" ,我想分成两个字符串:

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

这意味着第一个字符串将包含'-'之前的字符,第二个字符串将包含'-'之后的字符。 我还想检查字符串中是否包含'-' 。 如果没有,我将抛出异常。 我怎样才能做到这一点?


#1楼

// 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 arrLis = new ArrayList(subject.length());

   while(strTkn.hasMoreTokens())
      arrLis.add(strTkn.nextToken());

   return arrLis.toArray(new String[0]);
}

#2楼

你也可以这样尝试

 String concatenated_String="hi^Hello";

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

#3楼

public class SplitTest {

    public static String[] split(String text, String delimiter) {
        java.util.List parts = new java.util.ArrayList();

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

#4楼

消耗最少资源的最快方法是:

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

#5楼

假如说

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


#6楼

使用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

假定如果-在您的字符串中不存在,它将返回给定的字符串,并且您不会获得任何异常。


#7楼

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

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

您可以使用以下语句按连字符/字符分割字符串:

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

#8楼

对于简单的用例, String.split()应该可以完成工作。 如果使用番石榴,则还有一个Splitter类,该类允许链接不同的字符串操作并支持CharMatcher :

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

#9楼

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

#10楼

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

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


#11楼

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

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

请注意,这需要一个正则表达式 ,因此请记住在必要时转义特殊字符 。

有 12个具有特殊含义的字符:反斜杠\\ ,脱字号^ ,美元符号$ ,句点或点. ,竖线或竖线符号| ,问号? ,星号或星号* ,加号+ ,左括号( ,右括号)和右括号[ ,左花括号{ ,这些特殊字符通常称为“元字符”。

因此,如果您想分割例如period / dot . 这表示正则表达式中的“ 任何字符 ”,可以使用反斜杠\\来转义单个特殊字符,例如split("\\\\.") ,或者使用字符类[]来表示文本字符,例如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()

如果您想在结果部分中保留分割字符,请使用正向环视 。 如果要使分割字符以左结尾,请在模式上加上?<= group前缀,以使用正向后视。

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

#12楼

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

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

如果数组长度不是2,则字符串的格式不为: string-string

String类中签出split()方法。

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int-


#13楼

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

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


#14楼

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

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] or [333-333,33] "333-333-33"分开,还是错误? 等等。


#15楼

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

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

#16楼

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

这里有很多分割字符串的例子,但是我很少对代码进行优化。


#17楼

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

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

并按预期它将打印:

[004, 034556]

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

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

对于以下示例意味着:

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

我们将得到三个字符串: [0, 0, 4]而不是Java 7及以前版本中的四个。 还要检查类似的问题 。


#18楼

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

#19楼

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

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

#20楼

使用Java 8:

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

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

#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楼

String s="004-034556";
for(int i=0;i

就像每个人都提到的那样,split()是最好的选择,可以在您的情况下使用。 替代方法可以使用substring()。


#23楼

这是两种实现它的方法。

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

#24楼

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

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

输出:

004
034556

#25楼

您可以简单地使用StringTokenizer将字符串分为两个或更多部分,无论是否存在任何类型的定界符:

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

#26楼

总结一下:Java中至少有五种分割字符串的方法:

  1. String.split():

     String[] parts ="10,20".split(","); 
  2. Pattern.compile(regexp).splitAsStream(输入):

     List 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 result = Splitter.on(",").split("1,2,3,4"); 
  5. Apache Commons StringUtils:

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

因此,您可以根据需要选择最佳选项,例如返回类型(数组,列表或可迭代)。

这是这些方法和最常见示例(如何按点,斜杠,问号等进行拆分)的概述。


#27楼

我只想编写一种算法,而不是使用Java内置函数:

public static List split(String str, char c){
    List 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;
}

#28楼

要拆分字符串,请使用String.split(regex)。 查看以下示例:

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

产量

004
034556

注意此分割(正则表达式)将正则表达式作为参数,请记住转义正则表达式特殊字符,如句点/点。


#29楼

您只需要考虑两种方法。

将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对象。 您也可以缓存该对象并为每个输入重置它,以实现最佳性能,但这会更加复杂并且不是线程安全的。


#30楼

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

#31楼

我使用了一个名为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值是:那些有注释的人正忙于寻找庇护所

你可能感兴趣的:(java,string)