Java 想知道一种不使用正则表达式而根据作为参数传递的分隔符拆分字符串的方法吗

我想要一种基于多个分隔符分割给定字符串的方法。我不想使用正则表达式来实现这一点，因为我必须在字符串拆分方法中使用enum来传递分隔符作为参数

我使用了枚举，并将分隔符作为参数传递，并将结果存储在一个列表中，该列表对于单个分隔符非常有效。但我无法解决下一部分，即需要根据另一个分隔符拆分剩余字符串

例如：

初始字符串=“一、二、三”

我能够以某种方式获得“一二三”或“一”和“二三”作为输出，但并非所有子字符串都在一个列表中。请参考下面的代码，了解到目前为止我所做的尝试

public class StringSplitter {

    public String givenString;
    public String givenSeparator;
    public String anotherSeparator;


    public StringSplitter (String givenString, String givenSeparator, String anotherSeparator) {
        this.givenString=givenString;
        this.givenSeparator=givenSeparator;
        this.anotherSeparator=anotherSeparator;
    }

    public List<String> SplitMethod() {

        List<String> FirstSplitList  = Arrays.asList(givenString.split(givenSeparator));

        System.out.println(FirstSplitList);

        StringBuilder sb = new StringBuilder();
        for (String ch:FirstSplitList) {
            if(ch.contains(anotherSeparator)) {
                sb.append(ch);  
            }

        }

        String newStringtoSplit = sb.toString();
        System.out.println(newStringtoSplit);
        List<String> newString = Arrays.asList(newStringtoSplit.split(anotherSeparator));
        System.out.println(newString);

        return newString;

    }   

    public static void main (String[] args) {

        StringSplitter var = new StringSplitter("one.two#three",Separator.dot.toString(),Separator.hash.toString());
        var.SplitMethod();
    }



    enum Separator{

        dot {
            public String toString() {
                return "\\.";
            }
        },

        hash {
            public String toString() {
                return "#";
            }
        },

        comma {
            public String toString() {
                return ",";
            }
        }

    }

}

公共类stringspliter{
公共字符串给定；
公共字符串给定分隔符；
公共字符串另一个分隔符；
公共字符串拆分器（字符串给定字符串、字符串给定分隔符、字符串其他分隔符）{
this.givenString=givenString；
this.givenSeparator=givenSeparator；
this.anotherSeparator=另一个separator；
}
公共列表拆分方法（）{
List FirstSplitList=Arrays.asList（givenString.split（givenSeparator））；
System.out.println（第一个拆分列表）；
StringBuilder sb=新的StringBuilder（）；
for（字符串ch:FirstSplitList）{
如果（ch.contains（另一个分离器））{
某人附加（ch）；
}
}
字符串newStringtoSplit=sb.toString（）；
System.out.println（newStringtoSplit）；
List newString=Arrays.asList（newStringtoSplit.split（另一个分隔符））；
System.out.println（新闻字符串）；
返回新闻字符串；
}   
公共静态void main（字符串[]args）{
StringSplitter var=newStringSplitter（“一.二#三”，Separator.dot.toString（），Separator.hash.toString（））；
变量SplitMethod（）；
}
枚举分隔符{
圆点{
公共字符串toString（）{
返回“\\”；
}
},
散列{
公共字符串toString（）{
返回“#”；
}
},
逗号{
公共字符串toString（）{
返回“，”；
}
}
}
}

---

当字符串为“1.2#3”且分隔符为“.”和“#”时，我希望代码2处理至少两个分隔符，并以下面的方式工作。输出应该是一个包含[1-2-3]的列表

这适用于任何数量的分离器。它假定输入的格式正确。

String.indexOf（）

返回参数值第一次出现的索引

public static List<String> split(String input, Separator... givenSeparators) {
    List<String> result=new ArrayList<>();
    int s1=0;
    for (Separator s:givenSeparators)
    {
        s1=input.indexOf(s.toString());
        result.add(input.substring(0, s1));
        input=input.substring(s1+1);
    }
    result.add(input);
    return result;
}

---

我的建议是用第一个分离器替换其他分离器。 如果分隔符像“1.2.3”一样重复出现，它也会起作用

公共类stringspliter{
公共字符串给定；
公共字符串[]分隔符；
公共字符串拆分器（字符串给定字符串、字符串…分隔符）{
this.givenString=givenString；
这个。分离器=分离器；
if（this.givenString==null | | this.separators==null | | this.separators.length<1）{
抛出新的IllegalArgumentException（“传递的参数无效”）；
}
}
公共列表拆分方法（）{
字符串newGivenString=givenString；
//用第一个分离器更换所有其他分离器
如果（分隔符长度>1）{
//跳过第一个分隔符
for（int-idx=1；idx

---

}

你知道番石榴的种类吗？嗨，维博特，谢谢你的回复。使用varargs并用第一个分隔符替换所有分隔符效果非常好。非常感谢。

public static List<String> split(String input, Separator... givenSeparators) {
    List<String> result=new ArrayList<>();
    int s1=0;
    for (Separator s:givenSeparators)
    {
        s1=input.indexOf(s.toString());
        result.add(input.substring(0, s1));
        input=input.substring(s1+1);
    }
    result.add(input);
    return result;
}

dot {
    public String toString() {
        return ".";
    }
},

public class StringSplitter {

public String givenString;
public String[] separators;

public StringSplitter (String givenString, String... separators) {
    this.givenString=givenString;
    this.separators = separators;

    if(this.givenString == null || this.separators == null || this.separators.length < 1 ) {
        throw new IllegalArgumentException("invalid arguments passed");
    }
}

public List<String> splitMethod() {

    String newGivenString = givenString;

    // replace all other separators with the first one
    if(separators.length > 1) {
        // skip the first separator
        for(int idx = 1; idx < separators.length; idx++) {
            newGivenString = newGivenString.replaceAll(separators[idx], separators[0]);
        }
    }

    List<String> splitList  = Arrays.asList(newGivenString.split(separators[0]));

   System.out.println(splitList);

    return splitList;

}   

public static void main (String[] args) {

    StringSplitter var = new StringSplitter("one.two#three",Separator.DOT.toString(),Separator.HASH.toString());
    var.splitMethod();

    var = new StringSplitter("one.two#three,four",Separator.DOT.toString(),Separator.HASH.toString(),Separator.COMMA.toString());
    var.splitMethod();

    var = new StringSplitter("one.two#three four",Separator.DOT.toString());
    var.splitMethod();
}



enum Separator{

    DOT {
        @Override
        public String toString() {
            return "\\.";
        }
    },

    HASH {
        @Override
        public String toString() {
            return "#";
        }
    },

    COMMA {
        @Override
        public String toString() {
            return ",";
        }
    }

}