How I would do it if I had to split using two substrings:

String mainString = "This is a dummy string with both_spaces_and_underscores!"
String delimiter1 = " ";
String delimiter2 = "_";
mainString = mainString.replaceAll(delimiter2, delimiter1);
String[] split_string = mainString.split(delimiter1);

Replace all instances of second delimiter with first and split with first.

Note: using replaceAll allows you to use regexp for delimiter2. So, you should actually replace all matches of delimiter2 with some string that matches delimiter1's regexp.

This negative looakahead based regex should work for you:

String repl = "abcdef".replaceAll("..(?!0 ");

PS: This will avoid appending space after last match, so you get this output:

"ab cd ef"

instead of:

"ab cd ef "

Use the substring(int beginIndex, int endIndex) method of the String class.

Usage of regexp for such a small piece of code can be really slow, if it is repeated thousands of times (e.g. like analysing Alfresco metadata for lot of documents).

Look at this snippet:

    String s = "{key=value}SOMETEXT";
    String[] e = null;
    long now = 0L;

    now = new Date().getTime();
    for (int i = 0; i < 3000000; i++) {
        e = s.split("(?<=})");
    }
    System.out.println("Regexp: " + (new Date().getTime() - now));

    now = new Date().getTime();
    for (int i = 0; i < 3000000; i++) {
        int idx = s.indexOf('}') + 1;
        e = new String[] { s.substring(0, idx), s.substring(idx) };
    }
    System.out.println("IndexOf:" + (new Date().getTime() - now));

result is

Regexp: 2544
IndexOf:113

This means that regexp is 25 times slower than a (easier) substring. Keep it in mind: it can make the difference between a efficient code and a elegant (!) one.

An alternative to processing the string directly would be to use a regular expression with capturing groups. This has the advantage that it makes it straightforward to imply more sophisticated constraints on the input. For example, the following splits the string into two parts, and ensures that both consist only of digits:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

class SplitExample
{
    private static Pattern twopart = Pattern.compile("(\\d+)-(\\d+)");

    public static void checkString(String s)
    {
        Matcher m = twopart.matcher(s);
        if (m.matches()) {
            System.out.println(s + " matches; first part is " + m.group(1) +
                               ", second part is " + m.group(2) + ".");
        } else {
            System.out.println(s + " does not match.");
        }
    }

    public static void main(String[] args) {
        checkString("123-4567");
        checkString("foo-bar");
        checkString("123-");
        checkString("-4567");
        checkString("123-4567-890");
    }
}

As the pattern is fixed in this instance, it can be compiled in advance and stored as a static member (initialised at class load time in the example). The regular expression is:

(\d+)-(\d+)

The parentheses denote the capturing groups; the string that matched that part of the regexp can be accessed by the Match.group() method, as shown. The \d matches and single decimal digit, and the + means "match one or more of the previous expression). The - has no special meaning, so just matches that character in the input. Note that you need to double-escape the backslashes when writing this as a Java string. Some other examples:

([A-Z]+)-([A-Z]+)          // Each part consists of only capital letters 
([^-]+)-([^-]+)            // Each part consists of characters other than -
([A-Z]{2})-(\d+)           // The first part is exactly two capital letters,
                           // the second consists of digits