How do I parse a String into an array

It seems that you may be looking for something like

String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";

Pattern p = Pattern.compile("(?<=\\{)[^{}]+(?=\\})|\\w+");
Matcher m = p.matcher(s);
List<String[]> tokens = new ArrayList<String[]>();
while (m.find()) {
    tokens.add(m.group().split("\\s+"));
}

String[][] result = tokens.toArray(new String[tokens.size()][]);

// lets see if it works as planned
System.out.println(Arrays.deepToString(result));

Output:

[[Mary], [Mark], [John, Brown], [Honey], [lollipop], [Badger], [Oh, My, God], [Such, stupid]]

Explanation:

"(?<=\\{)[^{}]+(?=\\})|\\w+" is regular expression which searches for

• (?<=\\{)[^{}]+(?=\\}) characters which are not { nor } and are between { and } (these brackets will not be included). (?<=...) and (?=...) are part of look-around mechanism
• or \\w+ one or more alphanumeric characters

After they will find all such tokens they will split them on any kind of one or more whitespace \\s+ to create separate array of strings so

• "foo".split("\\s+") will become array ["foo"]
• "foo bar".split("\\s+") will become array ["foo", "bar"]

Next I convert list of such arrays into two dimensional list using toArray method.

I am guessing substring containing {} brackets should be regarded as one?

I suggest you to use regex to parse the given string. I am not very friendly with regex myself, but something like below might be able to help you:

String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";
String p = "\\{[A-Za-z ]*\\}|\\w+";
Pattern pattern = Pattern.compile(p);
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
  System.out.println(matcher.group());
}

then expected output is:

Mary
Mark
{John Brown}
Honey
lollipop
Badger
{Oh My God}
{Such stupid}

Use

Pattern.compile("\\{[A-Za-z ]*\\}|\\w+")

to build a regex pattern.

Then call

pattern.matcher(input)

to get a matcher for the input string.

Then iterate over the resulting matches using

matcher.find()

For each match, add the output of

match.split("\\s+")

(which gives you an array of one or more words) to an array or List.

Here's something that is most likely not efficient, but it works, it's based on a lot of string manipulation and truncating parts off the string:

public class StringSplitter
{
    public static String[] transform(String string)
    {
        String[] splitString = string.split(" ");
        List<String> listOfStrings = new ArrayList<String>();
        int i = 0;
        while(i < splitString.length)
        {
            if(!splitString[i].startsWith("{"))
            {
                listOfStrings.add(splitString[i]);
                i++;
            }
            else
            {
                boolean concatEnd = false;
                StringBuffer sb = new StringBuffer();
                splitString[i] = splitString[i].substring(1);
                sb.append(splitString[i]);
                i++;
                while(!concatEnd) 
                {
                    if(!splitString[i].endsWith("}"))
                    {
                        sb.append(" " + splitString[i]);
                        i++;
                    } 
                    else
                    {
                        splitString[i] = splitString[i].substring(0, splitString[i].length()-1);
                        sb.append(" " + splitString[i]);
                        concatEnd = true;
                        i++;
                    }
                }
                listOfStrings.add(sb.toString());
            }
        }
        return listOfStrings.toArray(new String[listOfStrings.size()]);
    }

    public static void main(String[] args)
    {
        String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";
        for(String string : transform(s)) 
        {
            System.out.println(string);
        }
    }
}

Output:

Mary
Mark
John Brown
Honey
lollipop
Badger
Oh My God
Such stupid