Return to Answer

###Questions

###Potential slowness causes I guess your String.split could be the culprit (with more than one character a regex gets created; you should use

###Review

###Summary Overall, it's not bad. When speed is important, I'd go for something like

###Filling the maps

Questions

Potential slowness causes

I guess your String.split could be the culprit (with more than one character a regex gets created; you should use

Review

Summary

Overall, it's not bad. When speed is important, I'd go for something like

Filling the maps

MyParser parser = new MyParser(response).skip("hasProcess=");
boolean hasProcess = parser.readBoolean();
parser.skip("\nversion=");
int version = parser.readInt();
while (parser.skipIfLookingAt("\nDATACENTER=")) {
 parseDatacenter(parser, whatever...);
}

where content and index are instance variables. This part doesn't need any substring creation at all (and gets a bit unreadable because of this). Warning: Doing something like content = content.substring(index) (so you could use startsWith) would make it clearer but terribly slow as you'd copy a big part of the string a lot of times.

MyParser parser = new MyParser(response).skip("hasProcess=");
boolean hasProcess = parser.readBoolean();
parser.skip("\nversion=");
int version = parser.readInt();
while (parser.skipIfLookingAt("\nDATACENTER=")) {
 parser.parseDatacenter(parser, whatever...);
}

where content and index are instance variables. This part doesn't need any substring creation at all (and gets a bit unreadable because of this). Warning: Doing something like content = content.substring(index) (so you could use startsWith) would make it clearer but terribly slow as you'd copy a big part of the string a lot of times.

###Filling the maps

Now, I'd probably move all the functionality into MyParser, so that the parsing would be just

 private void parseResponse(String response) {
 new MyParser(response).parse();
 }

The parser would have fields like

 private final Map<String, Map<Integer, String>> primaryData;

so that I could write

void parseDatacenter() {
 String datacenter = readTill('\n');
 skip("\n\tTotalNumberOfServers:");
 int totalNumberOfServers = readInt();
 skip("\n\tprimary{"); 
 primaryData.put(datacenter, readMap());
 skip("\n\t");
}
Map<String, String> readMap() {
 Map<String, String> result = new HashMap<>();
 while (true) {
 String key = readTillAndSkip('=');
 String value = readTillOneOf("},");
 map.put(key, value);
 if (lookingAt('}') {
 break;
 }
 skip(", ");
 }
 return result;
}

As an example see this simple method

String readTillOneOf(String terminators) {
 int start = index;
 while (terminators.indexOf(content.charAt(index)) > -1) {
 ++index;
 }
 return content.substring(start, index);
}

I ignored quite some details like parsing numbers and I can't tell how many parsing methods you'll need, but basically it's all pretty simple. Just skip what's fixed and process what you want while looking for a terminator.

It could get a bit more complicated if you needed to be error-tolerant, like allowing multiple spaces, but then you could let some of your methods skip over them. Or, if it gets difficult, use regexes. But I don't think it gets complicated.

Note that I'm unsure why your parser is slow. There's a lot of splitting and this is the probable cause, but it's just a guess.