How to split a string into equal parts and store it in a string array

Question

I'm fairly new to Java and am stuck on a particular homework question where a String gets passes and from there I have to split it into parts equal to an Integer that was passed.

For example: String "HelloWorld" is input and it has to be divided by 2 and those parts then have to be put into an array that has two parts like: array[hello, world].

Is there anyway to do this using a FOR loop?

My code so far enters the whole String into each array element. Here is my code:

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

use sub string.does every word divide to 2 parts with same length?what should output if length is even? — Madhawa Priyashantha, Sep 30 '14 at 06:22
@Renjith: according to the code, there should be n - 1 parts each of the size `size` and 1 part more of size `size` or less. — Dmitry Bychenko, Sep 30 '14 at 06:27
Another test that has to pass for this question is a String that is 15 chars long getting passed and I have to divide it into 3 equal strings and store them in an array. — Nagash, Sep 30 '14 at 06:43

score 5 · Answer 1 · edited May 23 '17 at 12:00

There are many ways:

Here's the regex version:

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 is a zero-width assertion that matches the position where the previous match ended. If there was no previous match, it matches the beginning of the input, the same as \A. The enclosing lookbehind matches the position that's four characters along from the end of the last match.

Both lookbehind and \G are advanced regex features, not supported by all flavors. Furthermore, \G is not implemented consistently across the flavors that do support it. This trick will work (for example) in Java, Perl, .NET and JGSoft, but not in PHP (PCRE), Ruby 1.9+ or TextMate (both Oniguruma).

Using Substring:

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

You should also check this answer: Google Guava split

this should be the accepted answer, because it's concise, elegant, well documented and shows a proper function as requested in the OP (not like the rest of the answers being whatever); in other words: it is the best answer. one improvement though: integer ceiling is done fast with `ceil(a/b) = (a + b - 1)/b` (@Rohit already showed it too) — nix, Nov 20 '18 at 19:56

score 4 · Answer 2 · answered Sep 30 '14 at 06:31

4

First check if the length of the string is a multiple of the divisor:

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

Then you know that you can grab equal chunks of it. So you use substring to pull them out, in a loop.

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

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

Will cycle through and grab a chunk that is divisor long each time.

answered Sep 30 '14 at 06:31

christopher

26,815
5
55
89

Ur answer is reasonable – Muhammad Sep 30 '14 at 06:33
The string is always divisible by the number for my questions. – Nagash Sep 30 '14 at 06:37
Does your answer store the chunks in an array? – Nagash Sep 30 '14 at 06:39
@Nagash how about my answer? – Kick Buttowski Sep 30 '14 at 06:39
@Nagash Do you want to be stored in different arrays? or just one array which does not make sense – Kick Buttowski Sep 30 '14 at 06:39
It has to be stored in one array for the tests to pass. – Nagash Sep 30 '14 at 06:46
This is all you're getting out of me I'm afraid. Store them Into an array if you want them to pass the test – christopher Sep 30 '14 at 06:55

score 3 · Answer 3 · answered Sep 30 '14 at 06:46

Try the following application.It is dividing the provided word into equal parts based on the provided size per part

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

}

Good Luck !!!!

score 2 · Answer 4 · answered Sep 30 '14 at 06:27

You can use Brute force

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

score 2 · Answer 5 · answered Sep 30 '14 at 06:29

2

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

Try subSequence();

answered Sep 30 '14 at 06:29

mujeeb.omr

499
2
12

Kick Buttowski · Answer 6 · 2014-09-30T06:40:38.950

2

Since length of a string is dived by 2

Code:

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

Output:

Hello
World

Explanation: you add to firstPart String as long as your index has not met the middle index of the String. When it passed the middle index of String, you make the secondPart

edited Sep 30 '14 at 06:40

answered Sep 30 '14 at 06:34

Kick Buttowski

6,709
13
37
58

I'd rather not use += with String: it re-creates the `firstPart` as well as `secondPart` and could be (for large input) time consuming. Why don't you just put `firstPart = st.substring(bla-bla-bla); secondPart = st.substring(some-other-bla-bla-bla);`? – Dmitry Bychenko Sep 30 '14 at 06:43
@DmitryBychenko thank you for your input, but the op ask for using the for loop – Kick Buttowski Sep 30 '14 at 06:44
1

I need code that can work for varrying string lengths and divisions. – Nagash Sep 30 '14 at 06:45
@Nagash but you said it is dividable by 2? am I right? this works for that – Kick Buttowski Sep 30 '14 at 06:45

score 2 · Answer 7 · edited May 23 '17 at 12:09

2

This is not plagarism, formatted the answer mentioned here - https://stackoverflow.com/a/3761521 as per the question.

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

        int parts = str.length()/3;

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

    }

edited May 23 '17 at 12:09

Community

1
1

answered Sep 30 '14 at 06:37

Piyush Jajoo

1,095
2
18
27

Ruchira Gayan Ranaweera · Answer 8 · 2014-09-30T06:59:27.133

Just looking at your input HelloWorld, You are trying to substring your input by Upper case letter.

You should go with that.

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]

If you want to get final result in to an array you can use

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

score 1 · Accepted Answer · answered Oct 01 '14 at 05:18

I figured it out. Here is my code:

    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;

score 1 · Answer 10 · answered Mar 13 '17 at 05:32

A Simple solution is like

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

score 0 · Answer 11 · answered Feb 07 '20 at 22:27

You can do it using regex as follows:

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

Output:

[Hello, World]
[Hell, oWor, ld]
[He, ll, oW, or, ld]

How to split a string into equal parts and store it in a string array

11 Answers11

Here's the regex version:

Using Substring:

Linked