Question

如何使用从输入字符串中提取的多个分隔符在Java中拆分字符串？（分隔符在方括号内，它们可以是两个或更多）：

"//[delim1][delim2]\n"

我试过了：

        Pattern p = Pattern.compile("\\[(.*?)\\]");
        Matcher m = p.matcher(s);
        String[] delimiters;
        int c=0;
        while (m.find() and c<counter) { //counter is a number of occurences of square brackets
            delimiters[c] = m.group(1);
            c++;
        }
        nums = s.split(delimiters));

但显然分裂并没有将一个字符串数组作为参数

例如，如果我拿字符串

"//[*][%]\n1*2%3"

我应该只考虑\ n之后的子字符串，它应该返回数字1,2和3

Answer 1

类split中方法java.lang.String的参数是正则表达式。 Java 8中的方法文档在这里：

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

提供样本输入和预期输出。

Answer 2

以下是使用String split()并使用正则表达式提供三个分隔符（数字，空格，文字问号）的示例：

class Main {
    public static void main(String[] args) {
        String str = "foo stack3overflow bar?regex\njava";
        String[] arr = str.split("(\\d|\\s|\\?)");
        System.out.println(java.util.Arrays.toString(arr));
    }
}

输出：

[foo, stack, overflow, bar, regex, java]

这是另一个可以动态选择分隔符的示例。问题是分隔符需要产生有效的正则表达式，因此我不确定这是否是您正在寻找的。作为一种公共方法，它几乎肯定不可靠/有用。

替代方案是在非正则表达式模式上反复拆分（可能很慢）或滚动自己的split迭代并切断非正则表达式（可能容易出错）。

class Main {
    public static void main(String[] args) {
        String[] delimiters = {" ", "\n", "\\?", "\\d"};
        String str = "foo stack3overflow bar?regex\njava";
        String pattern = "(" + String.join("|", delimiters) + ")";
        String[] arr = str.split(pattern);
        System.out.println(java.util.Arrays.toString(arr));
    }
}

输出：

[foo, stack, overflow, bar, regex, java]

更新：查看您的示例输入（"//[*][%]\n1*2%3"），代码和所需的输出：[1, 2, 3]，如下所示：

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        String str = "//[*][%]\n1*2%3";
        String pattern = "\\d";

        ArrayList<String> matches = new ArrayList<>();
        Matcher m = Pattern.compile(pattern).matcher(str);

        while (m.find()) {
           matches.add(m.group());
        }

        System.out.println(matches.toString());
    }
}

Answer 3

一种可能性是迭代一个分隔符列表：

class Ocl {
  public static ArrayList<String> split(String str, List<String> delimiters)
  { if (0 < delimiters.size()) 
    { String delim = delimiters.get(0); 
      List<String> taildelims = Ocl.tail(delimiters); 

      String[] splits = str.split(delim);
   
      ArrayList<String> res = new ArrayList<String>(); 
      for (int j = 0; j < splits.length; j++) 
      { res.addAll(Ocl.split(splits[j], taildelims)); }
      return res; 
    }
    ArrayList<String> result = new ArrayList<String>(); 
    result.add(str); 
    return result; 
  }
}

public static <T> ArrayList<T> tail(List<T> a)
{ ArrayList<T> res = new ArrayList<T>(); 
  for (int i = 1; i < a.size(); i++)
  { res.add(a.get(i)); } 
  return res; 
}

围绕多个char序列拆分字符串

3 个答案: