Question

我对Java很陌生，而且我遇到了一个特殊的家庭作业问题，其中一个String得到了传递，从那里我必须将它分成等于传递的整数的部分。

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

无论如何使用FOR循环来执行此操作？

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

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;
}

Answer 1

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

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

然后你知道你可以抓住它的相同块。因此，您可以使用substring将它们拉出来。

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

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

每次循环并抓取一个divisor长的块。

Answer 2

有很多方法：

这是正则表达式版本：

public void splitEqual(String s){
        int length = s.length();//Get string length
        int whereToSplit;//store where will split

            if(length%2==0) whereToSplit = length/2;//if length number is pair then it'll split equal
            else whereToSplit = (length+1)/2;//else the first value will have one char more than the other

        System.out.println(Arrays.toString(s.split("(?<=\\G.{"+whereToSplit+"})")));//split the string

    }

\G是一个零宽度断言，匹配上一个匹配结束的位置。如果没有先前的匹配，则它与输入的开头匹配，与\A.相同。封闭的lookbehind匹配从上一次匹配结束开始的四个字符的位置。

lookbehind和\ G都是高级正则表达式功能，并非所有版本都支持。此外，\G并未在支持它的各种风格中实现一致。这个技巧（例如）可以在Java，Perl，.NET和JGSoft中使用，但不能在PHP（PCRE），Ruby 1.9+或TextMate（都是Oniguruma）中使用。

使用子字符串：

/**
     * Split String using substring, you'll have to tell where to split
     * @param src String to split
     * @param len where to split
     * @return 
     */
    public static String[] split(String src, int len) {
        String[] result = new String[(int)Math.ceil((double)src.length()/(double)len)];
        for (int i=0; i<result.length; i++)
            result[i] = src.substring(i*len, Math.min(src.length(), (i+1)*len));
        return result;
    }

您还应该检查以下答案：Google Guava split

Answer 3

你可以使用暴力

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;
}

Answer 4

String s = "HelloWorld";
String firts_part=(String) s.subSequence(0, s.length() / 2);
String second_part=(String) s.subSequence((s.length() / 2)+1,s.length()-1 );

尝试subSequence（）;

Answer 5

因为字符串的长度是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

解释：只要您的索引未满足String的中间索引，就会添加到firstPart String。当它通过String的中间索引时，您将生成secondPart

Answer 6

这不是瘟疫，根据问题格式化了这里提到的答案 - https://stackoverflow.com/a/3761521。

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

        int parts = str.length()/3;

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

    }

Answer 7

尝试以下应用程序。它根据每个部分提供的大小将提供的单词划分为相等的部分

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;
  }

}

祝你好运!!!!

Answer 8

只是查看您的输入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);

Out put：

[Hello, World, User]

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

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

Answer 9

我明白了。这是我的代码：

    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;

Answer 10

简单的解决方案就像

 static void split(String str, int n) {
    int partSize = str.length() / n;
    while (str.length() - partSize > 0) {
        String s = str.substring(0, partSize-1);
        System.out.print(s + " ");
        str = str.substring(partSize-1);
    }
    if (str.length() > 0) {
        System.out.print(str);
    }
}

Answer 11

您可以使用正则表达式执行以下操作：

<script>
  const scriptURL = 'https://script.google.com/macros/s/XXXX/exec'
  const form = document.forms['submit-to-google-sheet']

  form.addEventListener('submit', e => {
    e.preventDefault()
    fetch(scriptURL, { method: 'POST', body: new FormData(form)})
      .then(response => console.log('Success!', response))
      .catch(error => console.error('Error!', error.message))
  })
</script>

输出：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Tests
        System.out.println(Arrays.toString(splitIntoParts("HelloWorld", 5)));
        System.out.println(Arrays.toString(splitIntoParts("HelloWorld", 4)));
        System.out.println(Arrays.toString(splitIntoParts("HelloWorld", 2)));
    }

    static String[] splitIntoParts(String word, int size) {
        return word.replaceAll("(.{" + size + "})", "$1\n").split("\n");
    }
}

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

11 个答案:

这是正则表达式版本：

使用子字符串：