Java 如何将字符串拆分为相等的部分并将其存储在字符串数组中

我对Java相当陌生，我被一个特殊的家庭作业问题困住了，在这个问题上，一个字符串被传递，从那里我必须将它分割成与传递的整数相等的部分

例如：字符串“HelloWorld”是输入的，它必须被2除，然后这些部分必须放入一个包含两部分的数组中，如：array[hello，world]

是否仍然可以使用FOR循环执行此操作

到目前为止，我的代码将整个字符串输入到每个数组元素中。这是我的密码：

String[] splitIntoParts(String word, int size) {

    String[] array = new String[size];     

    for (int i = 0; i < array.length; i++) {
        array[i] = word;
        println(array[i]);;
    }

    return array;
}

    String[] array = new String[size];
    char[] charArray = new char[length(word)];
    char[] temp = new char[length(word) / size];
    int place = 0;

    // turn the string into an array of chars
    for (int i = 0; i < charArray.length; i++) {
        charArray[i] = getChar(word, i);
    }

    // loop for each element of the desired string array
    for (int i = 0; i < array.length; i++) {

        // fill a temp array with the correct characters and the corect amount of characters
        for (int j = 0; j < charArray.length / size; j++) {                
            temp[j] = charArray[place];
            ++place;
        }

        // insert the temp array into each element of the string array
        array[i] = new String(temp);
    }

    return array;

String[]拆分为部分（字符串字，整数大小）{
字符串[]数组=新字符串[大小]；
for（int i=0；i

您可以使用蛮力

public static List<String> splitStringEqually(String text, int size) 
{
    List<String> result = new ArrayList<String>((text.length() + size - 1) / size);
    for (int i = 0; i < text.length(); i += size) {
        result.add(text.substring(i, Math.min(text.length(), i + size)));
    }
    return result;
}

公共静态列表平均拆分字符串（字符串文本，整数大小）
{
列表结果=新的ArrayList（（text.length（）+size-1）/size）；
对于（int i=0；i

您可以使用蛮力

public static List<String> splitStringEqually(String text, int size) 
{
    List<String> result = new ArrayList<String>((text.length() + size - 1) / size);
    for (int i = 0; i < text.length(); i += size) {
        result.add(text.substring(i, Math.min(text.length(), i + size)));
    }
    return result;
}

公共静态列表平均拆分字符串（字符串文本，整数大小）
{
列表结果=新的ArrayList（（text.length（）+size-1）/size）；
对于（int i=0；i

尝试子序列（）

---

尝试子序列（）

首先检查字符串的长度是否是除数的倍数：

if(str.length() % divisor == 0) 

然后你就知道你可以从中获得相等的部分。因此，您可以使用

子字符串

以循环方式将它们拉出

while(str.length() > 0) {
     String nextChunk = str.substring(0,divisor);
     // store the chunk. 

    str = str.substring(divisor,str.length());
} 

---

每次将循环并获取一个

除数

长的块

首先检查字符串的长度是否是除数的倍数：

if(str.length() % divisor == 0) 

然后你就知道你可以从中获得相等的部分。因此，您可以使用

子字符串

以循环方式将它们拉出

while(str.length() > 0) {
     String nextChunk = str.substring(0,divisor);
     // store the chunk. 

    str = str.substring(divisor,str.length());
} 

---

每次将循环并获取一个

除数

长的块

因为字符串的长度除以2

代码：

        String st ="HelloWorld";
        String firstPart = "";
        String secondPart = "";
        for (int j = 0; j < st.length(); j++) {
            if ( j < st.length() /2) {
                firstPart += st.charAt(j);
            }else
                secondPart += st.charAt(j);
       }

        System.out.println(firstPart);
        System.out.println(secondPart);

Hello
World

---

解释：只要索引未满足字符串的中间索引，就可以添加到第一部分字符串。当它通过字符串的中间索引时，您将使用第二部分，因为字符串的长度除以2

代码：

        String st ="HelloWorld";
        String firstPart = "";
        String secondPart = "";
        for (int j = 0; j < st.length(); j++) {
            if ( j < st.length() /2) {
                firstPart += st.charAt(j);
            }else
                secondPart += st.charAt(j);
       }

        System.out.println(firstPart);
        System.out.println(secondPart);

Hello
World

解释：只要索引未满足字符串的中间索引，就可以添加到第一部分字符串。当它通过字符串的中间索引时，您可以使第二部分成为有很多方法：

以下是正则表达式的版本： 您还应该检查以下答案：

有很多方法：

以下是正则表达式的版本：

---

你也应该检查这个答案：

这不是瘟疫，格式化了这里提到的答案-根据问题

public static void main(String[] args){     
        String str = "HelloWorld";

        int parts = str.length()/3;

        System.out.println(Arrays.toString(
                str.split("(?<=\\G.{"+parts+"})")
            ));

    }

publicstaticvoidmain（字符串[]args）{
String str=“HelloWorld”；
int parts=str.length（）/3；
System.out.println（Arrays.toString(
str.split（（？这不是瘟疫，格式化了这里提到的答案-根据问题

public static void main(String[] args){     
        String str = "HelloWorld";

        int parts = str.length()/3;

        System.out.println(Arrays.toString(
                str.split("(?<=\\G.{"+parts+"})")
            ));

    }

publicstaticvoidmain（字符串[]args）{
String str=“HelloWorld”；
int parts=str.length（）/3；
System.out.println（Arrays.toString(
str.split（（？尝试以下应用程序。它根据每个部分提供的大小将提供的单词分成相等的部分

public class WordSpliter {

  public static void main(String[] args) {
      String[] words = new WordSpliter().splitter("abcdefghij", 4);
      for(String s : words) System.out.println(s);
  }

  private String[] splitter(String word, int size) {
      // Decide the size of the String array 
      int rest = word.length() % size;
      int arrSize = ((word.length() - rest) / size) + 1;

      // Declare the array and the start point of the word
      String[] words = new String[arrSize];
      int startPoint = 0;

      for (int i = 0; i < words.length; i++) {
          if (i + 1 == words.length) {
              words[i] = word.substring(startPoint, startPoint + rest);
          } else {
              words[i] = word.substring(startPoint, startPoint +  4);
              startPoint += 4;
          }
      }
      return words;
  }

公共类字拆分器{
公共静态void main（字符串[]args）{
String[]words=new WordSpliter（）.splitter（“abcdefghij”，4）；
对于（字符串s:words）System.out.println（s）；
}
专用字符串[]拆分器（字符串字，整数大小）{
//决定字符串数组的大小
int rest=word.length（）%size；
int arrSize=（（word.length（）-rest）/size）+1；
//声明数组和单词的起点
String[]words=新字符串[arrSize]；
int起始点=0；
for（int i=0；i

}

祝你好运！！！！
试试下面的应用程序。它根据每个部分提供的大小将提供的单词分成相等的部分

public class WordSpliter {

  public static void main(String[] args) {
      String[] words = new WordSpliter().splitter("abcdefghij", 4);
      for(String s : words) System.out.println(s);
  }

  private String[] splitter(String word, int size) {
      // Decide the size of the String array 
      int rest = word.length() % size;
      int arrSize = ((word.length() - rest) / size) + 1;

      // Declare the array and the start point of the word
      String[] words = new String[arrSize];
      int startPoint = 0;

      for (int i = 0; i < words.length; i++) {
          if (i + 1 == words.length) {
              words[i] = word.substring(startPoint, startPoint + rest);
          } else {
              words[i] = word.substring(startPoint, startPoint +  4);
              startPoint += 4;
          }
      }
      return words;
  }

公共类字拆分器{
公共静态void main（字符串[]args）{
String[]words=new WordSpliter（）.splitter（“abcdefghij”，4）；
对于（字符串s:words）System.out.println（s）；
}
专用字符串[]拆分器（字符串字，整数大小）{
//决定字符串数组的大小
int rest=word.length（）%size；
int arrSize=（（word.length（）-rest）/size）+1；
//声明数组和单词的起点
String[]words=新字符串[arrSize]；
int起始点=0；
for（int i=0；i

}

祝你好运！！！！
只要看看你的输入
HelloWorld
，你就在试图用大写字母代替你的输入

你应该这样做

String str = "HelloWorldUser";
List<Integer> indexList = new ArrayList<>();
for (int i = 0; i < str.length(); i++) {
    String temp = (str.charAt(i) + "").toUpperCase();
    if (temp.equals(str.charAt(i) + "")) { // check for upper case letters
       indexList.add(i);
      }
 }
List<String> subStrings = new LinkedList<>(); // to keep the insertion order
for (int i = indexList.size() - 1; i > -1; i--) { // substring reverse order
     subStrings.add(str.substring(indexList.get(i)));
     str=str.substring(0,indexList.get(i));
 }
Collections.reverse(subStrings); // reverse to get original order
System.out.println(subStrings);

如果要将最终结果输入到数组中，可以使用

String[] arr= subStrings.toArray(new String[subStrings.size()]);

只需查看您的输入
HelloWorld
，您就可以尝试用大写字母替代您的输入

你应该这样做

String str = "HelloWorldUser";
List<Integer> indexList = new ArrayList<>();
for (int i = 0; i < str.length(); i++) {
    String temp = (str.charAt(i) + "").toUpperCase();
    if (temp.equals(str.charAt(i) + "")) { // check for upper case letters
       indexList.add(i);
      }
 }
List<String> subStrings = new LinkedList<>(); // to keep the insertion order
for (int i = indexList.size() - 1; i > -1; i--) { // substring reverse order
     subStrings.add(str.substring(indexList.get(i)));
     str=str.substring(0,indexList.get(i));
 }
Collections.reverse(subStrings); // reverse to get original order
System.out.println(subStrings);

如果要将最终结果输入到数组中，可以使用

String[] arr= subStrings.toArray(new String[subStrings.size()]);

我想出来了。这是我的代码：

String[] splitIntoParts(String word, int size) {

    String[] array = new String[size];     

    for (int i = 0; i < array.length; i++) {
        array[i] = word;
        println(array[i]);;
    }

    return array;
}

    String[] array = new String[size];
    char[] charArray = new char[length(word)];
    char[] temp = new char[length(word) / size];
    int place = 0;

    // turn the string into an array of chars
    for (int i = 0; i < charArray.length; i++) {
        charArray[i] = getChar(word, i);
    }

    // loop for each element of the desired string array
    for (int i = 0; i < array.length; i++) {

        // fill a temp array with the correct characters and the corect amount of characters
        for (int j = 0; j < charArray.length / size; j++) {                
            temp[j] = charArray[place];
            ++place;
        }

        // insert the temp array into each element of the string array
        array[i] = new String(temp);
    }

    return array;

String[]数组=新字符串[size]；
char[]charArray=新字符[长度（字）]；
字符[]t