Java 在包含分隔符的拆分方法上创建my

我正在尝试创建自己的分割方法，该方法在输出中包含分隔符。到目前为止，我有以下代码：

private static String[] split(String string, String regex) throws InterruptedException {
    ArrayList<String> output = new ArrayList<String>();
    String leftovers = string;

    if (regex.charAt(0) != '[' && regex.charAt(regex.length() - 1) != ']') {
        int i = 0;
        while (!leftovers.isEmpty()) {
            if (i == leftovers.indexOf(regex)) {
                if (!leftovers.substring(0, leftovers.indexOf(regex)).isEmpty()) {
                    output.add(leftovers.substring(0, leftovers.indexOf(regex)));
                }
                output.add(regex);
                leftovers = leftovers.substring(i + regex.length());
                i = 0;
            } else if (leftovers.indexOf(regex) == -1) {
                output.add(leftovers);
                leftovers = "";
            } else {
                i++;
            }
        }
    } else {
        char[] regexChars = new char[regex.length() - 2];
        for (int i = 0; i < regexChars.length; i++) {
            regexChars[i] = regex.charAt(i + 1);
        }

        int i = 0;

        for (int j = 0; j < regexChars.length; j++) {
            while (!leftovers.isEmpty()) {


                if (i == leftovers.indexOf(regexChars[j])) {
                    if (!leftovers.substring(0, leftovers.indexOf(regexChars[j])).isEmpty()) {
                        output.add(leftovers.substring(0, leftovers.indexOf(regexChars[j])));
                    }
                    output.add(Character.toString(regexChars[j]));
                    leftovers = leftovers.substring(i + 1);
                    i = 0;
                } else if (leftovers.indexOf(regexChars[j]) == -1) {
                    output.add(leftovers);
                    leftovers = "";
                } else {
                    i++;
                }
            }
        }
    }
    return output.toArray(new String[0]);

}       

private static String[]split（String String，String regex）抛出InterruptedException{
ArrayList输出=新的ArrayList（）；
字符串剩余=字符串；
if（regex.charAt（0）！='['&®ex.charAt（regex.length（）-1）！=']'）{
int i=0；
而（！leftovers.isEmpty（））{
if（i==剩余索引of（regex））{
if（！leftovers.substring（0，leftovers.indexOf（regex））.isEmpty（））{
add（leftovers.substring（0，leftovers.indexOf（regex））；
}
output.add（regex）；
leftovers=leftovers.substring（i+regex.length（））；
i=0；
}else if（leverts.indexOf（regex）=-1）{
输出。添加（剩余）；
剩菜=”；
}否则{
i++；
}
}
}否则{
char[]regexChars=新字符[regex.length（）-2]；
for（int i=0；i

我试图传递的输入参数是“a？b？gf#e”和“[？#]”。但是，我得到的输出是

[a，b，gf，null，e]

。如果将正则表达式中的分隔符反转为“[#？]”，则得到

[a，a？b？gf#e]

---

谁能告诉我我做错了什么？仅供参考，我不想使用Pattern和Matcher类，我们根本不允许使用内置的split方法。

我不知道您为什么要创建自己的

split（）

方法。您应该构建一个将分隔符作为单独数组元素返回的正则表达式。将该正则表达式与现有的

split（）

方法一起使用。这会很有效

如果要在分隔符上拆分-

[？#]

，同时将分隔符保留为单独的数组项，则在这些分隔符前面和后面的空字符串上拆分。这将完成工作：

String str = "a?b?gf#e";        
String[] arr = str.split("(?<=[?#])|(?=[?#])");
System.out.println(Arrays.toString(arr));  // [a, ?, b, ?, gf, #, e]

String str=“a？b？gf#e”；
String[]arr=str.split（（？这是我的解决方案。它工作得很好，它将忽略任何不属于拆分的内容。希望这对man有所帮助。如果您有任何问题，请告诉我

public static String[] split(String str, String regex)
    {
        Vector<String> result = new Vector<String>();

    int start = 0;
    int pos = str.indexOf(regex);
    char[] charArray = new char[regex.length()];;

    if(regex.length() > 1){
        for(int i = 0; i< regex.length();i++){
            charArray[i] = regex.charAt(i);
        }
        for(char chars:charArray){
            {
                pos = str.indexOf(Character.toString(chars));
                while (pos>=start) {
                    if (pos>start) {
                        result.add(str.substring(start,pos));
                    }
                    start = pos + 1;
                    result.add(Character.toString(chars));
                    pos = str.indexOf(Character.toString(chars),start); 
                    System.out.println(pos);
                }
            }
        }
    }else{
        while (pos>=start) {
            if (pos>start) {
                result.add(str.substring(start,pos));
            }
            start = pos + regex.length();
            result.add(regex);
            pos = str.indexOf(regex,start); 
        }
        if (start<str.length()) {
            result.add(str.substring(start));
        }
    }
    String[] array = result.toArray(new String[0]);
    return array;
}
}

publicstaticstring[]split（stringstr，stringregex）
{
向量结果=新向量（）；
int start=0；
int pos=str.indexOf（regex）；
char[]charArray=新字符[regex.length（）]；；
if（regex.length（）>1）{
对于（int i=0；i=开始）{
如果（位置>开始）{
结果.添加（str.substring（start，pos））；
}
开始=位置+1；
结果.add（Character.toString（chars））；
pos=str.indexOf（Character.toString（chars），start）；
系统输出打印项次（pos）；
}
}
}
}否则{
while（位置>=开始）{
如果（位置>开始）{
结果.添加（str.substring（start，pos））；
}
start=pos+regex.length（）；
结果。添加（正则表达式）；
pos=str.indexOf（regex，start）；
}
如果（开始你为什么要创建自己的拆分方法？Guava splitter类非常优秀，顺便说一句，
split
使用正则表达式，那么为什么不使用零宽度断言，即查找来定义你的分隔符？@RohitJain我们在Ebemded设备的Java 1.3中没有自定义拆分的原因。你能给出一个例子吗ct输出？？？仅供参考，这是一个家庭作业，我们需要创建自己的包含分隔符的拆分。@PinkJazz他们告诉你创建自己的
split（）
此任务的方法？是的，我们必须构建自己的拆分方法。@PinkJazz对于家庭作业，我确信您不允许使用正则表达式拆分，所以请通过检查每个字符分隔符是否位于分隔符的eof上，自己实现它。
public static String[] split(String str, String regex)
    {
        Vector<String> result = new Vector<String>();

    int start = 0;
    int pos = str.indexOf(regex);
    char[] charArray = new char[regex.length()];;

    if(regex.length() > 1){
        for(int i = 0; i< regex.length();i++){
            charArray[i] = regex.charAt(i);
        }
        for(char chars:charArray){
            {
                pos = str.indexOf(Character.toString(chars));
                while (pos>=start) {
                    if (pos>start) {
                        result.add(str.substring(start,pos));
                    }
                    start = pos + 1;
                    result.add(Character.toString(chars));
                    pos = str.indexOf(Character.toString(chars),start); 
                    System.out.println(pos);
                }
            }
        }
    }else{
        while (pos>=start) {
            if (pos>start) {
                result.add(str.substring(start,pos));
            }
            start = pos + regex.length();
            result.add(regex);
            pos = str.indexOf(regex,start); 
        }
        if (start<str.length()) {
            result.add(str.substring(start));
        }
    }
    String[] array = result.toArray(new String[0]);
    return array;
}
}