Regular Expression on string with braces in Java

Hi guys,

I hope you could help me with these.  I need a regular expression that could split up the string below

{adfsadfd}{sdads}{asdf{asdf}{asdf}}{asdfsdf{dads}}

into

{adfsadfd}
{sdads}
{asdf{asdf}{asdf}}
{asdfsdf{dads}}



Currently I have "\\{([.*]*)[^}]*}"   but it doesn't work. It will also include the groups inside, which i don't want


Thanks in advance
xanbiAsked:
Who is Participating?
 
ozoCommented:
([{](?:[^{]|[{][^{}]*})*})
0
 
mrjoltcolaCommented:
I would suggest that for recursive grammars, regular expressions are not usually adequate. You can usually write a "good enough" solution, but it will not be bulletproof for the whole grammar. There is a limit to how you can employ lookahead and lookbehind in a non-recursive approach, which regular expressions are.

Recursive descent parsers can be written for special cases, and I have provided a sample that will not descend into the nested {} as you asked. In a real parser we would usually return tree nodes and parse until there is no nesting left, but since you want the nesting to be preserved past 1 level, here is a sample that works, maybe you can use it.

// Simple recursive descent parser for matching nested tokens
public class Main {
	  public static void main(String [] args) {
	       String s = "{adfsadfd}{sdads}{asdf{asdf}{asdf}}{asdfsdf{dads}}";
	       String token;
	       int beginIndex = 0;
	       while((token = match(s.substring(beginIndex))) != null) {
	    	   System.out.println(token);
	    	   beginIndex += token.length();
	       }
	   }
 
	   public static String match(String s) {
	      int i = 0; char ch;
	      if(s == null || s.length() == 0)
	    	  return null;
	      String token = "";
	      if((ch =s.charAt(i++)) != '{') // not a valid start pattern
	    	  return null;
	      token += ch;
	      while(i < s.length()) {
	    	  ch = s.charAt(i);
	    	  if(ch == '}') { // end of top level {} pattern
	    		  token += ch;
	    		  return token;
	    	  }
	    	  else if(ch != '{') { // non bracket, add to the token
	    		  token += ch;
	    		  i++;
	    	  }
	    	  else { // nested {, so recursively match and concat sub-strings
	    		  String subtoken = match(s.substring(i));
	    		  if(subtoken != null) {
	    			  token += subtoken;
	    			  i += subtoken.length();
	    		  }
	    	  }
	      }
	      
	      return token;
	   }
}

Open in new window

0
 
xanbiAuthor Commented:
Thank you very much.  I accepted ozo solution because I should use regular expression prior to making scan through the string.

Regards
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

All Courses

From novice to tech pro — start learning today.