Regex that match spaces if not inside {...} in Java

<br>
I am trying to find Regular Expression that will match every space if it is not between { } in any combination. I have already come up with this one \s(?![^{]*})+ but it's not working correctly!<br>
<a href="https://i.stack.imgur.com/5NYW0.png>link to image</a> <br>
As you can see on the image its matching those spaces marked in red rectangle even though they are between { }, only not exatly between { } but between { { and that something that I do not want to... <br>
There are some examples to understand what regex I want because its a little but complex: <br>

1. <br>
   lol.something.xd 1 F 1.99 #adasdaops {something.awesome 4 8 9} null T; = Match every space here simply if not inside { }!
   <br>
2. <br>
   lol.something.xd-1-F-1.99-#adasdpopu-{something.awesome 4 8 9 5 {#adsadasdasd} null F T {something.awesome.Foo 7 8 9 4545 T} null null F T}-45.5F-null-{alpha.beta.gama 45}-45-null; = Match only spaces that are represented as "-"
   <br>
   I need this regex to split Strings in Java if it matters.
   <br><br>
   Note: Unfortunately, Java does not support recursive regex so keep it on mind in future answers!
   <br>
   Side Note: The web page is not showing code fences on my question from some reason. Maybe only I do not see it, but If you too and you know why then please fix it.

The general idea for "match X, but not when it's inside Y" is to match Y, discard it, and then match X.

Matching arbitrarily nested braces is in itself no easy task, as it requires a recursive regex.

Here's a regex that should work for your needs, and some explanation:

/(\{(?:(?>[^{}]+)|(?1))*\})(*SKIP)(*FAIL)| /g

What a mess!

/
  ( # first subpattern
    \{ # match an opening brace
    (?: # subpattern
      (?> # atomic group (don't backtrack this, avoids Catastrophic Backtrack)
        [^{}]+ # match one or more non-brace characters
      )
    | # or...
      (?1) # recursively match the first subpattern (ie. nested braces)
    )* # zero or more times
    \} # match a closing brace
  )
  (*SKIP) # skip this part of the subject string
  (*FAIL) # always fails, which excludes the contents of the braces from the match
| # or (ie. if the skipped part doesn't happen)
[space] # match a space
/g # find all matches

However, not all flavours of regex support verbs like (*SKIP)(*FAIL), and others don't support recursive regexes. In these cases, you will need some kind of parser.

That's going to be more work, but the general idea will be to break your string down and go character-by-character. If it's a {, increment a counter. If it's }, decrease the counter. If it's a space, then do something with it only if the counter is zero.

Finally I manage to solve this problem for my self!
Based on posted answers I realized that regex is not going to work in this case. So I decided to solve it using some regular Java stuff and I come up with this freak:

	public static String[] splitValues(String s)
{
	List<String> resault = new ArrayList<>();
	
	for (int i = 0, brackets = 0, lastIndex = 0; i < s.length(); i++)
	{
		if (s.charAt(i) == ' ' && brackets == 0)
			resault.add(s.substring(lastIndex == 0 ? 0 : lastIndex + 1, lastIndex = i));
		else if (s.charAt(i) == '{')
			brackets++;
		else if (s.charAt(i) == '}')
		{
			if (brackets > 0)
				brackets--;
			else
				throw new IllegalArgumentException("Unclosed or missing: { or } at index " + i);
		}
		
		if (i == s.length()-1 && brackets > 0)
			throw new IllegalArgumentException("Unclosed or missing: { or }");
		else if (i == s.length()-1)
			resault.add(s.substring(lastIndex == 0 ? 0 : lastIndex + 1, s.length()));
	}
	
	return resault.toArray(new String[0]);
}

It is ugly and long and also not solving the regex thing that I have originally asked but it solves the main problem for me and that is the point. But If somebody eventually finds a regex solution just feel free to post it! But after all, I simply do not think so it is possible because remember while posting Java has no recursive regex! <br>
Also, that function above is now a part of SerialX, one of my libs!