Java 如何拆分字符串数组并将字符串存储在另一个数组中

我有一个字符串数组，它包含

“-”

。所以我必须拆分这些字符串来存储它们

比如说

字符串s[]={“a”、“b”、“c”、“-”、“g”、“t”、“t”、“q”、“-”、“a”、“s”、“d”、“-”、“a”、“b”、“y”}

到

字符串k[]={“abc”、“gt”、“q”、“asd”、“aby”}

我试过的代码是

 public static void main(String...a)
{


String s[]={"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};

int sop=0;

                 String[] sdf=new String[100];

 for(int kk=0;kk<s.length;kk++)
             {

              if(s[sop].equals("-"))
              {

              }
              else
              {
              sdf[sop]=s[sop];

               sop++;
              }

             }
}

publicstaticvoidmain（字符串…a）
{
字符串s[]={“a”、“b”、“c”、““-”、“g”、“t”、“q”、“q”、“d”、“a”、“s”、“d”、“a”、“b”、“y”}；
int-sop=0；
字符串[]sdf=新字符串[100]；
对于（int kk=0；kk如果
s[sop]。等于（“-”）
，则不增加sop。您必须每次增加它。而且它可以减少到

          if(!s[sop].equals("-"))
          {
              sdf[sop]=s[sop];
          }
          sop++;

也可以使用循环计数器kk代替sop

另一种方法是

遍历第一个数组并将所有元素联系到字符串
使用String.split方法获取最终数组

StringBuilder sB=新建StringBuilder（）；

对于（字符串温度：s）

某人附加（临时）；

字符串[]输出=sB.toString（）.split（“-”）

如果
s[sop]。等于（“-”
），则不能增加sop。您必须每次都增加它。而且它还可以减少到

          if(!s[sop].equals("-"))
          {
              sdf[sop]=s[sop];
          }
          sop++;

也可以使用循环计数器kk代替sop

另一种方法是

遍历第一个数组并将所有元素联系到字符串
使用String.split方法获取最终数组

StringBuilder sB=新建StringBuilder（）；

对于（字符串温度：s）

某人附加（临时）；

字符串[]输出=sB.toString（）.split（“-”）

这里有几个问题：


当你到达一个“-”时，你就停止递增
sop
。我想你应该使用
s[kk]
而不是
s[sop]
每次获得新字符时，都不会将它们附加到现有字符串中，而是将它们添加到新的数组单元格中

此外，对于第二个数组，考虑使用<代码> ARAYLISTAB/CODE >，因为您最初不知道它的大小。
以下是更正的版本：

for (int kk = 0; kk < s.length; kk++) {

    if (!s[kk].equals("-")) {
        if (sdf[sop] != null) {
            sdf[sop] += s[kk];
        } else {
            sdf[sop] = s[kk];
        } 
    } else {
        sop++;
    }

}

for（int-kk=0；kk
这里有几个问题：


当你到达一个“-”时，你就停止递增
sop
。我想你应该使用
s[kk]
而不是
s[sop]
每次获得新字符时，都不会将它们附加到现有字符串中，而是将它们添加到新的数组单元格中

此外，对于第二个数组，考虑使用<代码> ARAYLISTAB/CODE >，因为您最初不知道它的大小。
以下是更正的版本：

for (int kk = 0; kk < s.length; kk++) {

    if (!s[kk].equals("-")) {
        if (sdf[sop] != null) {
            sdf[sop] += s[kk];
        } else {
            sdf[sop] = s[kk];
        } 
    } else {
        sop++;
    }

}

for（int-kk=0；kk
逻辑错误：在两个数组中使用相同的迭代器，从s[]检索值时，应该使用for循环迭代器kk

public static void main(String...a)
     {
     String s[]={"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};

     String[] sdf=new String[100];
     int sop = 0;
      for(int kk=0;kk<s.length;kk++)
      {
          if(!s[kk].equals("-"))
          {
              sdf[sop]=s[kk];
              sop++;
          }
      }
     }

publicstaticvoidmain（字符串…a）
{
字符串s[]={“a”、“b”、“c”、““-”、“g”、“t”、“q”、“q”、“d”、“a”、“s”、“d”、“a”、“b”、“y”}；
字符串[]sdf=新字符串[100]；
int-sop=0；
对于（int kk=0；kk逻辑错误：在两个数组中使用相同的迭代器，从s[]检索值时，应该使用for循环迭代器kk

public static void main(String...a)
     {
     String s[]={"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};

     String[] sdf=new String[100];
     int sop = 0;
      for(int kk=0;kk<s.length;kk++)
      {
          if(!s[kk].equals("-"))
          {
              sdf[sop]=s[kk];
              sop++;
          }
      }
     }

publicstaticvoidmain（字符串…a）
{
字符串s[]={“a”、“b”、“c”、““-”、“g”、“t”、“q”、“q”、“d”、“a”、“s”、“d”、“a”、“b”、“y”}；
字符串[]sdf=新字符串[100]；
int-sop=0；
对于（int kk=0；kk您必须从字符串数组开始吗

您可能希望使用来解析带有“-”的字符串

String s[] = { "a", "b", "c", "-", "g", "t", "-", "q", "-", "a", "s",
                "d", "-", "a", "b", "y" };

// Join the letters to make a full string
String s_full = "";
for (String letter : s) {
    s_full += letter;
}

StringTokenizer st = new StringTokenizer(s_full, "-");  //Tokenize
String[] words = new String[st.countTokens()];
int i = 0;
while (st.hasMoreTokens()) {
    words[i++] = st.nextToken();    //Add to result array
}

// Print result
for (String word : words) {
    System.out.println(word);
}

您必须从字符串数组开始吗

您可能希望使用来解析带有“-”的字符串

String s[] = { "a", "b", "c", "-", "g", "t", "-", "q", "-", "a", "s",
                "d", "-", "a", "b", "y" };

// Join the letters to make a full string
String s_full = "";
for (String letter : s) {
    s_full += letter;
}

StringTokenizer st = new StringTokenizer(s_full, "-");  //Tokenize
String[] words = new String[st.countTokens()];
int i = 0;
while (st.hasMoreTokens()) {
    words[i++] = st.nextToken();    //Add to result array
}

// Print result
for (String word : words) {
    System.out.println(word);
}

您可以这样尝试：

public static void main(String[] args) {
    String[] s = {"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};
    StringBuilder builder = new StringBuilder();
    ArrayList<String> k = new ArrayList<String>();
    for (String str : s) {
        if (str.equals("-")) {
            k.add(builder.toString());
            builder.setLength(0);
        } else builder.append(str);
    }
    k.add(builder.toString());
    System.out.println(Arrays.toString(k.toArray(new String[k.size()])));
}

您可以这样尝试：

public static void main(String[] args) {
    String[] s = {"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};
    StringBuilder builder = new StringBuilder();
    ArrayList<String> k = new ArrayList<String>();
    for (String str : s) {
        if (str.equals("-")) {
            k.add(builder.toString());
            builder.setLength(0);
        } else builder.append(str);
    }
    k.add(builder.toString());
    System.out.println(Arrays.toString(k.toArray(new String[k.size()])));
}

保持在你的环境中：

public static void main(String[] a) {


    String s[]={"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};

    int sop=0;

    String[] sdf=new String[100];
    String temp = "";

    for(int kk=0;kk<s.length;kk++){
        if(s[kk].equals("-")){
            sdf[sop] = temp;
            temp = "";
            sop++;
        } else {
            temp += s[kk];
        }
    }
}

publicstaticvoidmain（字符串[]a）{
字符串s[]={“a”、“b”、“c”、““-”、“g”、“t”、“q”、“q”、“d”、“a”、“s”、“d”、“a”、“b”、“y”}；
int-sop=0；
字符串[]sdf=新字符串[100]；
字符串temp=“”；
对于（int-kk=0；kk留在您的上下文中：

public static void main(String[] a) {


    String s[]={"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};

    int sop=0;

    String[] sdf=new String[100];
    String temp = "";

    for(int kk=0;kk<s.length;kk++){
        if(s[kk].equals("-")){
            sdf[sop] = temp;
            temp = "";
            sop++;
        } else {
            temp += s[kk];
        }
    }
}

publicstaticvoidmain（字符串[]a）{
字符串s[]={“a”、“b”、“c”、““-”、“g”、“t”、“q”、“q”、“d”、“a”、“s”、“d”、“a”、“b”、“y”}；
int-sop=0；
字符串[]sdf=新字符串[100]；
字符串temp=“”；
对于（int kk=0；kk，您可以这样做：

    String s[]={"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};

    String split = "-";

    ArrayList<String> list = new ArrayList<String>();
    String temp = "";

    for(int i = 0 ; i < s.length ; i++){
        if(s[i].equals(split)){
            list.add(temp);
            temp = new String();
        }else{
            temp += s[i];
        }
    }

    String array[] =  list.toArray(new String[list.size()]);

    for(String str : array){
        System.out.println(str); // output : abc;gt;q;asd;
    }

字符串s[]={“a”、“b”、“c”、“-”、“g”、“t”、“t”、“q”、“-”、“a”、“s”、“d”、“-”、“a”、“b”、“y”}；
字符串拆分=“-”；
ArrayList=新建ArrayList（）；
字符串temp=“”；
对于（int i=0；i
您可以这样做：

    String s[]={"a","b","c","-","g","t","-","q","-","a","s","d","-","a","b","y"};

    String split = "-";

    ArrayList<String> list = new ArrayList<String>();
    String temp = "";

    for(int i = 0 ; i < s.length ; i++){
        if(s[i].equals(split)){
            list.add(temp);
            temp = new String();
        }else{
            temp += s[i];
        }
    }

    String array[] =  list.toArray(new String[list.size()]);

    for(String str : array){
        System.out.println(str); // output : abc;gt;q;asd;
    }

字符串s[]={“a”、“b”、“c”、“-”、“g”、“t”、“t”、“q”、“-”、“a”、“s”、“d”、“-”、“a”、“b”、“y”}；
字符串拆分=“-”；
ArrayList=新建ArrayList（）；
字符串temp=“”；
对于（int i=0；i
我想要这样的东西：

String s[] = { "a", "b", "c", "-", "g", "t", "-", "q", "-", "a", "s", "d", "-", "a", "b", "y" };
String delimiter = "-";

List<String> result = new ArrayList<String>();  
StringBuilder group = new StringBuilder();
for (String character : s) {
    if (delimiter.equals(character) && !"".equals(group)) {
        result.add(group.toString());
        group.setLength(0);
    } else {
        group.append(character);
    }
}

if (!"".equals(group)) {
    result.add(group.toString());
}

我想要这样的东西：

String s[] = { "a", "b", "c", "-", "g", "t", "-", "q", "-", "a", "s", "d", "-", "a", "b", "y" };
String delimiter = "-";

List<String> result = new ArrayList<String>();  
StringBuilder group = new StringBuilder();
for (String character : s) {
    if (delimiter.equals(character) && !"".equals(group)) {
        result.add(group.toString());
        group.setLength(0);
    } else {
        group.append(character);
    }
}

if (!"".equals(group)) {
    result.add(group.toString());
}

使用字符串生成器更明智，但使用sop迭代器从s[]中提取是所提供代码的问题。我不知道为什么我不能将后面的部分作为代码。有人能帮忙吗？使用字符串生成器更明智，但使用sop迭代器