final int mid = s1.length() / 2; //get the middle of the String
String[] parts = {s1.substring(0, mid),s1.substring(mid)};
System.out.println(parts[0]); //first part
System.out.println(parts[1]); //second part

You can do it for example like this:

String base = "somestring";
int half = base.length() % 2 == 0 ? base.length()/2 : base.length()/2 + 1;
String first = base.substring(0, half);
String second = base.substring(half);

Simply when n is the string's length, if n is divisible by 2, split the string in n/2, otherwise split in n/2 + 1 so that first substring is one character longer than second.

There's no obvious regex pattern that would do this. It may be possible to do this with String.split, but I'd just use substring like this:

    String s = "12345678abcdefgh";

    final int mid = s.length() / 2;
    String[] parts = {
        s.substring(0, mid),
        s.substring(mid),
    };

    System.out.println(Arrays.toString(parts)); 
    // "[12345678, abcdefgh]"

The above would split an odd-length String with part[1] one character longer than part[0]. If you need it the other way around, then simply define mid = (s.length() + 1) / 2;

N-part split

You can also do something like this to split a string into N-parts:

static String[] splitN(String s, final int N) {
    final int base = s.length() / N;
    final int remainder = s.length() % N;

    String[] parts = new String[N];
    for (int i = 0; i < N; i++) {
        int length = base + (i < remainder ? 1 : 0);
        parts[i] = s.substring(0, length);
        s = s.substring(length);
    }
    return parts;
}

Then you can do:

    String s = "123456789";

    System.out.println(Arrays.toString(splitN(s, 2)));  
    // "[12345, 6789]"

    System.out.println(Arrays.toString(splitN(s, 3)));
    // "[123, 456, 789]"

    System.out.println(Arrays.toString(splitN(s, 5)));  
    // "[12, 34, 56, 78, 9]"

    System.out.println(Arrays.toString(splitN(s, 10))); 
    // "[1, 2, 3, 4, 5, 6, 7, 8, 9, ]"

Note that this favors the earlier parts to hold the extra characters, and it also works when the number of parts is more than the number of characters.

Appendix

In the above code:

• ?: is the conditional operator, aka the ternary operator.
• / performs integer division. 1 / 2 == 0.
• % performs integer remainder operation. 3 % 2 == 1. Also, -1 % 2 == -1.

References

• JLS 15.25 Conditional Operator ?:
• JLS 15.17.2 Division Operator /
• JLS 15.17.3 Remainder Operator %

Related questions

• How does the ternary operator work?
• Why does (360 / 24) / 60 = 0 … in Java

Try this:

import java.util.Stack;
class Hackerearth{
    public static void main(String args[] ) throws Exception {
        Stack<String> st = new Stack<>();
        String str = "aaaa bbbb cccc dddd";
        st.push(str);
        split(st);
    }

    public static void split(Stack<String> st){
        while(!st.empty()){
            String s = st.pop();
            if(s.length() == 1){
                System.out.println(s);
            }
            else{
                int mid = s.length() / 2;
                String first = s.substring(0, mid);
                String second = s.substring(mid, s.length());
                st.push(second);
                st.push(first);
            }
        }
    }
}

You can use Stack in Java.util package.. It has push and pop methods predefined to add and remove items.. Stack Documentation

To make it dynamically, do it based on array length and split it in two:

int [] x= {8,7,5,6,2,4,3,1};
int len = x.length;

int a[] = Arrays.copyOfRange(mergeSort(x), 0, len/2);
int b[] = Arrays.copyOfRange(mergeSort(x), (len/2), len);

System.out.println("A: " + Arrays.toString(a));
System.out.println("B: " + Arrays.toString(b));

Hope it helps.