首页 文章

如何在Java中拆分字符串

提问于
浏览
1362

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

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

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

30 回答

  • 10
    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() .

  • 15

    你可以使用方法拆分

    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 \"-\".");
            }
    
        }
    }
    
  • 70
    // 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]);
    }
    
  • 9

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

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

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

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

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

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

    产量

    004
    034556
    

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

  • 24

    String Split with multiple characters using Regex

    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版本中,其中第一个空字符串被忽略 . 最新的JDK版本中不存在此错误,但在JDK 1.7后期版本和1.8早期版本之间存在某些版本 .

  • 40

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

    这里有很多分裂字符串的例子,但我的代码经过优化 .

  • 15

    你也可以这样试试

    String concatenated_String="hi^Hello";
    
     String split_string_array[]=concatenated_String.split("\\^");
    
  • 15

    对于简单的用例String.split()应该做的工作 . 如果你使用guava,还有一个Splitter类,允许链接不同的字符串操作并支持CharMatcher

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

    最快的方式,也消耗最少的资源可能是:

    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 '-'
    }
    
  • 0
    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);
        }
    }
    
  • 0

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

    • String.split():
    String[] parts ="10,20".split(",");
    
    • Pattern.compile(regexp).splitAsStream(输入):
    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);
    }
    
    • Google Guava Splitter:
    Iterable<String> result = Splitter.on(",").split("1,2,3,4");
    
    • Apache Commons StringUtils:
    String[] strings = StringUtils.split("1,2,3,4", ",");
    

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

    Here概述了这些方法和最常见的例子(如何用点,斜线,问号等分割)

  • 0

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

    Use String.split if a one character delimeter or you don't care about performance

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

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

    如果分隔符是单个字符而不在上面的列表中,则split方法具有避免使用正则表达式的优化 . 否则,它必须编译正则表达式,这不是理想的 .

    Use Pattern.split and precompile the pattern if using a complex delimeter and you care about performance

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

    // Save this somewhere
    Pattern pattern = Pattern.compile("[,;:]");
    
    /// ... later
    String[] results = pattern.split(input);
    

    最后一个选项仍然会创建一个新的 Matcher 对象 . 您还可以缓存此对象并为每个输入重置它以获得最佳性能,但这有点复杂,而且不是线程安全的 .

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

    直接处理字符串的替代方法是使用带捕获组的正则表达式 . 这样做的优点是可以直接表示对输入的更复杂的约束 . 例如,以下内容将字符串拆分为两部分,并确保两者都只包含数字:

    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
    
  • 4

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

    以下两种方式实现它 .

    方法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);
            }
        }
    }
    
  • 5

    假如说

    • 你真的不需要正则表达式来进行拆分

    • 你碰巧已经在你的应用程序中使用了apache commons lang

    最简单的方法是使用StringUtils#split(java.lang.String, char) . 那个's more convenient than the one provided by Java out of the box if you don't需要正则表达式 . 就像它的手册所说,它的工作原理如下:

    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,因为它通常包含很多可用的东西 . 但是,如果除了进行拆分之外你不需要它,那么实现自己或逃避正则表达式是一个更好的选择 .

  • 15

    只需使用适当的方法: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 ](http://www.regular-expressions.info/characters.html)来转义单个特殊字符,如 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 . 如果您希望拆分字符最终位于左侧,请在模式上使用 ?<= group前缀来使用正向lookbehind .

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

    如果您希望将拆分字符放在右侧,请在模式上使用 ?= group前缀来使用正向前瞻 .

    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
    
  • 13
    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-

  • 9

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

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

    正如预期的那样,它将打印:

    [004, 034556]
    

    在这个答案中我也想指出 one change that has taken place for split method in Java 8 . String#split()方法使用 Pattern.split ,现在它将在结果数组的开头删除空字符串 . 请注意Java 8文档中的change

    如果在输入序列的开头存在正宽度匹配,则在结果数组的开头包含空的前导子字符串 . 然而,开头的零宽度匹配从不会产生这样的空前导子串 .

    它意味着以下示例:

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

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

  • 7

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

    方法签名:

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

    在您的情况下,您希望在存在“ - ”时拆分字符串 .

    你可以简单地做如下:

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

    Output:

    004
    034556
    

    假设如果字符串中不存在 - ,它将返回给定的字符串,并且不会出现任何异常 .

  • 7
    String str="004-034556"
    String[] sTemp=str.split("-");// '-' is a delimiter
    
    string1=004 // sTemp[0];
    string2=034556//sTemp[1];
    
  • 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] or [333-333,33] 中分隔 "333-333-33" 还是错误?等等 .

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

    应该做你想做的事 . String类有许多用string操作的方法 .

  • 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;
    }
    
  • 2463

    一种方法是在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
    
  • 0

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

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

    输出:

    004
    034556
    
  • 0

    无论是否有任何类型的分隔符,您都可以使用StringTokenizer将字符串拆分为两个或多个部分:

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

    使用Java 8:

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

相关问题