带有用户指定分隔符的Java数组-split（）

我正在尝试编写一个简单的程序，它接受两个用户输入：一个要拆分的字符串和一个指定一个或多个分隔符的字符串。程序应该打印一个字符串数组，该数组由拆分的子字符串和分隔符组成。我必须实现公共静态字符串[]拆分（字符串s，字符串regex）

如果要拆分的字符串为

cd#34#abef#1256

我当前的代码输出正确

[cd, 34, abef, 1256]

我需要输出的是

[cd, #, 34, abef, #, 1256]

如果要拆分的字符串有两个用户指定的分隔符呢

cd?34?abef#1256

我怎样才能把它分割成这样

[cd, ?, 34, ?, abef, #, 1256]

public static String[] split(String s, String regex)
    {
        String[] myString = s.split("["+regex+"]");
        return myString;
    }

我之前研究的问题都没有使用用户指定的字符串和分隔符

以下是我当前的代码：

import java.util.Arrays;
import java.util.Scanner;

public class StringSplit
{
    public static void main(String[] args)
    { 
        Scanner scan = new Scanner(System.in);
        System.out.print("Enter a string: ");
        String str = scan.next();
        System.out.print("Specify delimiter(s): ");
        String del = scan.next();
        String[] result = split(str, del);
        System.out.print(Arrays.toString(result));
    }

    public static String[] split(String s, String regex)
    {
        String[] myString = s.split(regex);
        return myString;
    }
}

---

您可以直接使用正则表达式和循环，如下所示：

List<String> parts = new ArrayList<>();
Pattern p = Pattern.compile("(#|\\?|[^#\\?]+)");
Matcher m = p.matcher(s);
while(m.find()) {
  parts.add(m.group(1));
}

List parts=new ArrayList（）；
Pattern p=Pattern.compile（“（\\\？\[^\\？]+）”；
匹配器m=匹配器p；
while（m.find（））{
增加（m.组（1））；
}

---

请注意，regexp只是一个字符串。如果要使用自定义分隔符，可以动态创建模式。

可以直接使用正则表达式和循环，如下所示：

List<String> parts = new ArrayList<>();
Pattern p = Pattern.compile("(#|\\?|[^#\\?]+)");
Matcher m = p.matcher(s);
while(m.find()) {
  parts.add(m.group(1));
}

List parts=new ArrayList（）；
Pattern p=Pattern.compile（“（\\\？\[^\\？]+）”；
匹配器m=匹配器p；
while（m.find（））{
增加（m.组（1））；
}

---

请注意，regexp只是一个字符串。如果要使用自定义分隔符，可以动态创建模式。

您可以使用此基于前视和后视的正则表达式进行拆分：

(?<=#)|(?=#)

您的Java方法可以是：

public static String[] split(String s, String d) {
    String del = Pattern.quote(d);
    String[] myString = s.split("(?<=[" + del + "])|(?=[" + del + "])");
    return myString;
}

输出：

[aa, {, bb, }, (, cc, ), [, dd, ], ee, #, ff, ., ., ., gg, ?, hh, *, +, ii]

---

您可以使用此基于前向和后向的正则表达式进行拆分：

(?<=#)|(?=#)

您的Java方法可以是：

public static String[] split(String s, String d) {
    String del = Pattern.quote(d);
    String[] myString = s.split("(?<=[" + del + "])|(?=[" + del + "])");
    return myString;
}

输出：

[aa, {, bb, }, (, cc, ), [, dd, ], ee, #, ff, ., ., ., gg, ?, hh, *, +, ii]

split（）

自己动手：

public static List<String> split(String text, String delimiters) {
    List<String> result = new ArrayList<>();
    int start = 0;
    for (int i = 0; i < text.length(); i++)
        if (delimiters.indexOf(text.charAt(i)) != -1) {
            if (start < i)
                result.add(text.substring(start, i));
            result.add(text.substring(i, i + 1));
            start = i + 1;
        }
    if (start < text.length())
        result.add(text.substring(start));
    return result;
}

试验

输出

[cd，#，34，#，abef，#，1256]
[cd，34，abef，#，1256]
[aa，{，bb，}，（，cc，），[，dd，]，ee，#，ff，，，gg，，，hh，*，+，ii]

注意：第三个测试用例可能会在尝试使用regex的任何实现上失败。
split（）
根据定义排除了分隔符，因此除非使用零宽度的前向/后向组，否则无法使用它，即使这样，您也可能会遇到特殊字符的问题

自己动手：

public static List<String> split(String text, String delimiters) {
    List<String> result = new ArrayList<>();
    int start = 0;
    for (int i = 0; i < text.length(); i++)
        if (delimiters.indexOf(text.charAt(i)) != -1) {
            if (start < i)
                result.add(text.substring(start, i));
            result.add(text.substring(i, i + 1));
            start = i + 1;
        }
    if (start < text.length())
        result.add(text.substring(start));
    return result;
}

试验

输出

[cd，#，34，#，abef，#，1256]
[cd，34，abef，#，1256]
[aa，{，bb，}，（，cc，），[，dd，]，ee，#，ff，，，gg，，，hh，*，+，ii]

注意：第三个测试用例可能会在尝试使用regex的任何实现上失败。
这是针对一个delimeter的，您可以将其扩展为第二个delimeter

import java.util.Arrays;
import java.util.Scanner;

public class StringSplit
{
    public static void main(String[] args)
    { 
        Scanner scan = new Scanner(System.in);
        System.out.print("Enter a string: ");
        String str = scan.next();
        System.out.print("Specify delimiter(s): ");
        String del = scan.next();
        String[] result = split(str, del);
        System.out.print(Arrays.toString(result));
    }

    public static String[] split(String s, String regex)
    {
        String[] myString = s.split(regex);
        int templength = myString.length;
        String[] temp = new String[(2*templength)];
        int y=0;
        for (int i=0;i<templength ;i++) {

            temp[y] = myString[i];

            temp[++y] = regex;
            y++;

        }
       String temp2[]= Arrays.copyOf(temp, temp.length-1);
        return temp2;
    }
}

导入java.util.array；
导入java.util.Scanner；
公共类StringSplit
{
公共静态void main（字符串[]args）
{ 
扫描仪扫描=新扫描仪（System.in）；
System.out.print（“输入字符串：”）；
String str=scan.next（）；
System.out.print（“指定分隔符）：”；
String del=scan.next（）；
字符串[]结果=拆分（str，del）；
System.out.print（Arrays.toString（result））；
}
公共静态字符串[]拆分（字符串s，字符串正则表达式）
{
字符串[]myString=s.split（regex）；
int-templength=myString.length；
字符串[]临时=新字符串[（2*模板长度）]；
int y=0；
对于（inti=0；i这是一个delimeter，您将其展开为第二个delimeter

import java.util.Arrays;
import java.util.Scanner;

public class StringSplit
{
    public static void main(String[] args)
    { 
        Scanner scan = new Scanner(System.in);
        System.out.print("Enter a string: ");
        String str = scan.next();
        System.out.print("Specify delimiter(s): ");
        String del = scan.next();
        String[] result = split(str, del);
        System.out.print(Arrays.toString(result));
    }

    public static String[] split(String s, String regex)
    {
        String[] myString = s.split(regex);
        int templength = myString.length;
        String[] temp = new String[(2*templength)];
        int y=0;
        for (int i=0;i<templength ;i++) {

            temp[y] = myString[i];

            temp[++y] = regex;
            y++;

        }
       String temp2[]= Arrays.copyOf(temp, temp.length-1);
        return temp2;
    }
}

导入java.util.array；
导入java.util.Scanner；
公共类StringSplit
{
公共静态void main（字符串[]args）
{ 
扫描仪扫描=新扫描仪（System.in）；
System.out.print（“输入字符串：”）；
String str=scan.next（）；
System.out.print（“指定分隔符）：”；
String del=scan.next（）；
字符串[]结果=拆分（str，del）；
System.out.print（Arrays.toString（result））；
}
公共静态字符串[]拆分（字符串s，字符串正则表达式）
{
字符串[]myString=s.split（regex）；
int-templength=myString.length；
字符串[]临时=新字符串[（2*模板长度）]；
int y=0；
对于（int i=0；i使用字符[]并比较每个字符的简单解决方案：

public static void main(String[] args)
{ 
    // example string
    String str = "vv*aabb?eegg?fff";
    char[] chars=str.toCharArray();

    // list of delimiters
    List<Character> delimiters = new ArrayList<Character>();
    delimiters.add('*');
    delimiters.add('?');
    StringBuilder sb=new StringBuilder();

    for(int i=0 ; i<chars.length;i++){
        if (delimiters.contains(chars[i])){
            // if its a delimiter - add commas
            sb.append(", " + chars[i] + ", ");
        } else {
            // if not - add the char only
            sb.append(chars[i]);
        }
    }
    System.out.println(sb.toString());
}

publicstaticvoidmain（字符串[]args）
{ 
//示例字符串
String str=“vv*aabb？eegg？fff”；
char[]chars=str.toCharArray（）；
//分隔符列表
列表分隔符=新的ArrayList（）；
分隔符。添加（'*'）；
分隔符。添加（“？”）；
StringBuilder sb=新的StringBuilder（）；
对于（int i=0；i使用字符[]并比较每个字符的简单解决方案：

public static void main(String[] args)
{ 
    // example string
    String str = "vv*aabb?eegg?fff";
    char[] chars=str.toCharArray();

    // list of delimiters
    List<Character> delimiters = new ArrayList<Character>();
    delimiters.add('*');
    delimiters.add('?');
    StringBuilder sb=new StringBuilder();

    for(int i=0 ; i<chars.length;i++){
        if (delimiters.contains(chars[i])){
            // if its a delimiter - add commas
            sb.append(", " + chars[i] + ", ");
        } else {
            // if not - add the char only
            sb.append(chars[i]);
        }
    }
    System.out.println(sb.toString());
}

publicstaticvoidmain（字符串[]args）
{ 
//示例字符串
String str=“vv*aabb？eegg？fff”；
char[]chars=str.toCharArray（）；
//分隔符列表
列表分隔符=新的ArrayList（）；
分隔符。添加（'*'）；
分隔符。添加（“？”）；
StringBuilder sb=新的StringBuilder（）；
对于（int i=0；i，在您的例子中，regexp必须如下所示[？#]

这就是拆分方法的外观

[cd, ?, 34, ?, abef, #, 1256]

public static String[] split(String s, String regex)
    {
        String[] myString = s.split("["+regex+"]");
        return myString;
    }

在您的情况下，regexp必须如下所示[？#]

这就是拆分方法的外观

[cd, ?, 34, ?, abef, #, 1256]

public static String[] split(String s, String regex)
    {
        String[] myString = s.split("["+regex+"]");
        return myString;
    }

您可以根据分隔符使用正则表达式，并在appendReplacement/appendTail上进行攻击，以捕获不匹配的字符。下面是代码及其说明：

public class SplitWithDelimiter {

  //Do compilation on build, make instance thread-safe !
  private final Pattern pattern;
  public SplitWithDelimiter(String regex) {
    pattern = Pattern.compile(regex);
  }

  public List<String> split(String string) {
    List<String> substrings = new ArrayList<>(); // Value to return

    Matcher m = pattern.matcher(string);         // Matcher to find delimiters
    StringBuffer buffer = new StringBuffer();    // Buffer to reuse (see hack belows)

    while (m.find()) {                           // Find next

      m.appendReplacement(buffer, "");           // Hack: Append non-matched characters to the empty buffer
      substrings.add(buffer.toString());         // Adds buffer content
      buffer.delete(0, buffer.length());         // Reset buffer (but keep allocate char array)

      substrings.add(m.group());                 // Adds matched delimiter 
    }

    m.appendTail(buffer);                        // Hack: Append left characters to the empty buffer
    substrings.add(buffer.toString());           // Adds buffer content

    return substrings;
  }

  public static void main(String[] args) {

    String input = "?cd?34?abef#1256";  // User input
    String chars = "#?";

    String regex = "[" + Pattern.quote(chars) + "]";  // Builds a regular expression from char list
    List<String> splits = new SplitWithDelimiter(regex).split(input); // Do the split
    System.out.println(splits);
  }
}

使用分隔符拆分公共类{
//在构建时进行编译，使实例线程安全！
私人最终模式；
公共SplitWithDelimiter（字符串正则表达式）{
pattern=pattern.compile（regex）；
}
公共列表拆分（字符串）{
List substring=new ArrayList（）；//要返回的值
Matcher m=pattern.Matcher（string）；//查找分隔符的Matcher
StringBuffer=new StringBuffer（）；//要重用的缓冲区（请参阅下面的hack）
而（m.find（））{//find next
m、 appendReplacement（缓冲区“”；//Hack:Append n