有问题的行格式为：
1:{O:{o1,Brasil,F1,G2,E1},N:{n1,Albania,D2,V2,R2,E1,A2}}
关键是，我使用
split(",")并有两个字符串，并且必须从每个字符串中创建一个具有上述属性的对象。如何读取每个属性并在相应位置使用它们？ 最佳答案
为此，我提供了两种特定的方法，这些方法可用于此任务以外的其他事情。
第一种方法是方括号MaxDepth（）方法，该方法返回特定嵌套方括号的深度。支持的括号是(), [], {}, <>。您感兴趣的方括号是花括号（{}）。
第二种方法是getNestedBracketedGroups（）方法，该方法将解析出（检索）带括号的字符串中嵌套括号组的内容，并返回一维（1D）字符串数组中的组内容。支持的括号是(), [], {}, <>。您感兴趣的方括号是花括号（{}）。
方括号MaxDepth（）方法由getNestedBracketedGroups（）方法在内部使用。例如，解析以下字符串：
String line = "1:{O:{o1,Brasil,F1,G2,E1}," +
"G:{g1,Germany,D2,V2,F1,G2,E1}," +
"N:{n1,Albania,D2,V2,R2,E1,A2}}";
我们可能会做这样的事情（我添加了一个额外的生物进行测试）：
String line = "1:{O:{o1,Brasil,F1,G2,E1},G:{g1,Germany,D2,V2,F1,G2,E1},N:{n1,Albania,D2,V2,R2,E1,A2}}";
line = line.trim();
// Get player Number
String player = line.substring(0, line.indexOf(":"));
// Is the player a string representation of a integer number?
if (!player.matches("\\d+")) {
// Nope...exit
return; // or whatever exit mechanism you need to use.
}
int playerNumber = Integer.parseInt(player);
// Get Player's Creatures...
String[] playerCreatures = getNestedBracketedGroups(line, 1, "{}",
true)[0].split(",(?![^\\{\\}]*\\})");
// Display creatures data
System.out.println("Creatures for Player #" + playerNumber);
for (int i = 0; i < playerCreatures.length; i++) {
String creat = playerCreatures[i];
int creatureNumber = i + 1;
String creatureType= creat.substring(0, creat.indexOf(":"));
// Get creature Attributes
String[] creatureAttributes = creat.substring((creatureType + ":").length() + 1,
creat.length() - 1).split("\\s{0,},\\s{0,}");
System.out.println("\tCreature #" + creatureNumber);
System.out.println("\t\tCreature Type: " + creatureType);
for (int j = 0; j < creatureAttributes.length; j++) {
System.out.println("\t\t\tAttribute #" + (j + 1) + ": " + creatureAttributes[j]);
}
}
解析到控制台窗口的输出如下所示：
Creatures for Player #1
Creature #1
Creature Type: O
Attribute #1: o1
Attribute #2: Brasil
Attribute #3: F1
Attribute #4: G2
Attribute #5: E1
Creature #2
Creature Type: G
Attribute #1: g1
Attribute #2: Germany
Attribute #3: D2
Attribute #4: V2
Attribute #5: F1
Attribute #6: G2
Attribute #7: E1
Creature #3
Creature Type: N
Attribute #1: n1
Attribute #2: Albania
Attribute #3: D2
Attribute #4: V2
Attribute #5: R2
Attribute #6: E1
Attribute #7: A2
方括号MaxDepth（）方法：
/**
* This method takes a string and returns the maximum depth of nested
* brackets. The bracket type to check the depth for is supplied within the
* bracketType parameter.<br><br>
*
* @param bracketedString (String) The string to process.<br>
*
* @param bracketType (String - Default is "()") Either a open bracket,
* or a close bracket, or both open and closed
* brackets can be supplied (no white-spaces). This
* method will process any <b>one</b> of 4 different
* bracket types and they are as follows:<pre>
*
* () Parentheses (Default)
* {} Curly Braces
* [] Square Brackets
* <> Chevron Brackets</pre>
*
* @return (Integer) The maximum depth of the supplied bracket type. 0 is
* returned if there are no brackets of the type supplied within the
* supplied string. -1 is returned if there is an unbalance within
* the supplied string of the supplied bracket type. For every open
* bracket there must be a close bracket and visa versa.
*/
public static int bracketsMaxDepth(String bracketedString, String... bracketType) {
char open = '('; // Default
char close = ')'; // Default
if (bracketType.length > 0) {
String bType = Character.toString(bracketType[0].charAt(0));
switch (bType) {
case "(":
case ")":
open = '(';
close = ')';
break;
case "{":
case "}":
open = '{';
close = '}';
break;
case "[":
case "]":
open = '[';
close = ']';
break;
case "<":
case ">":
open = '<';
close = '>';
break;
default:
throw new IllegalArgumentException("\nbracketsMaxDepth() Method Error!\n"
+ "Unknown bracket type supplied (" + bType + ")!\n");
}
}
int current_max = 0; // current count
int max = 0; // overall maximum count
int n = bracketedString.length();
char[] c = bracketedString.toCharArray();
// Traverse the input string
for (int i = 0; i < n; i++) {
if (c[i] == open) {
current_max++;
// update max if required
if (current_max > max) {
max = current_max;
}
}
else if (c[i] == close) {
if (current_max > 0) {
current_max--;
}
else {
return -1;
}
}
}
// finally check for unbalanced string
if (current_max != 0) {
return -1;
}
return max;
}
getNestedBracketedGroups（）方法：
/**
* This method will parse out (retrieve) the contents of nested brackets
* groups within a bracketed string and return those group contents within a
* 1D String Array. The best way to see how this works is by examples. Let's
* say we have the following bracketed string:
* <pre>
*
* String a = "1(2(3)(4))(5(6)(7))";</pre><br>
* <p>
* In the above string we can see that there are two instances of level 1
* bracketed groups which in each level 1 group nest two more level 2
* bracketed groups:
* <pre>
*
* Level 1 Level 2
* (2(3)(4)) (3) (4)
*
* ==================================
*
* Level 1 Level 2
* (5(6)(7)) (6) (7)</pre><br>
* <p>
* Bracketed groups: <b>(2(3)(4))</b> and <b>(5(6)(7))</b> are both
* considered to be at nest level 1 (level 1 is the outer most level). They
* are both individual groups because they both have their own set of outer
* brackets. Within each level 1 group we have two sets of level 2 bracketed
* groups (4 level 2 groups altogether) which consist of: <b>(3)</b> &
* <b>(4)</b> and <b>(6)</b> & <b>
* (7)</b>.<br><br>
* <p>
* This method also utilizes the TokenJar's StringUtils.BracketsMaxDepth()
* method.
*
* @param bracketedString (String) The string which contains bracketed
* content to parse.<br>
*
* @param desiredDepth (Integer) Default is 0 (full depth). The
* nested depth to retrieve bracketed content
* from.<br> If the bracket depth supplied is
* deeper than what is contained within the
* supplied input string then an <b>IllegalArgu-
* mentException</b> is thrown explaining as
* such.
*
* @param bracketType (String) You must supply the bracket type to
* process. This can be done by supplying either
* a single open or close bracket or both open
* and close brackets, for example, any one of
* the following are all acceptable entries if
* parentheses are required:<pre>
*
* "(" ")" "()" ")("</pre><br>
*
* Any one of four (4) bracket types can be supplied. The allowable Bracket
* Types are:
* <pre>
*
* () Parentheses
* {} Curly Braces
* [] Square Brackets
* <> Chevron Brackets</pre>
*
* @param removeOuterBrackets (Optional - Boolean - Default is false) By
* default the outer brackets for each found
* group are also attached to the returned
* results. If true is supplied to this optional
* parameter then the outer brackets are removed
* from the returned group results.<br>
*
* @return (1D String Array) The determined nested groups desired.<br>
*
* @throws IllegalArgumentException if a depth is supplied greater than the
* available bracketed depth contained
* within the supplied input string. This
* exception is also thrown if it is found
* that the supplied Bracket Type is
* unbalanced (open and closed braces are
* not properly paired) within the supplied
* input string.
*/
public static String[] getNestedBracketedGroups(String bracketedString, int desiredDepth,
String bracketType, boolean... removeOuterBrackets) {
boolean removeOuter = false;
if (removeOuterBrackets.length > 0) {
removeOuter = removeOuterBrackets[0];
}
int d = bracketsMaxDepth(bracketedString, bracketType);
if (desiredDepth == 0) {
//Default for this method is 0 (full depth).
desiredDepth = 1;
}
if (d == -1) {
// Throw Exception...
throw new IllegalArgumentException("\n\ngetNestedBracketedGroups() Method Error!\n"
+ "Brackets mismatch in supplied string!\n");
}
else if (d < desiredDepth) {
// Throw Another Exception...
throw new IllegalArgumentException("\n\ngetNestedBracketedGroups() Method Error!\n"
+ "Invalid Depth Supplied! Brackets within the supplied string go to a\n"
+ "maximum depth of (" + d + ") and therefore can not go to the supplied "
+ "depth\nof (" + desiredDepth + "). Change the desired depth.\n");
}
char open = '('; // Default
char close = ')'; // Default
String bType = Character.toString(bracketType.charAt(0));
switch (bType) {
case "(":
case ")":
open = '(';
close = ')';
break;
case "{":
case "}":
open = '{';
close = '}';
break;
case "[":
case "]":
open = '[';
close = ']';
break;
case "<":
case ">":
open = '<';
close = '>';
break;
default:
throw new IllegalArgumentException("\ngetNestedBracketedGroups() Method Error!\n"
+ "Unknown bracket type supplied (" + bType + ")!\n");
}
List<String> list = new ArrayList<>();
int n = bracketedString.length();
char[] c = bracketedString.toCharArray();
int depth = 0;
String strg = "";
for (int i = 0; i < n; i++) {
if (c[i] == open) {
depth++;
}
if ((depth >= desiredDepth)) {
if (c[i] == close) {
depth--;
}
strg += Character.toString(c[i]);
if (depth < desiredDepth) {
strg = strg.trim();
if (removeOuter) {
if (strg.startsWith(Character.toString(open))) {
strg = strg.substring(1);
}
if (strg.endsWith(Character.toString(close))) {
strg = strg.substring(0,
strg.lastIndexOf(Character.toString(close)));
}
}
list.add(strg);
strg = "";
}
continue;
}
if (c[i] == close) {
depth--;
}
if (!strg.equals("")) {
strg = strg.trim();
if (removeOuter) {
if (strg.startsWith(Character.toString(open))) {
strg = strg.substring(1);
}
if (strg.endsWith(Character.toString(close))) {
strg = strg.substring(0,
strg.lastIndexOf(Character.toString(close)));
}
}
list.add(strg);
strg = "";
}
}
if (!strg.equals("")) {
strg = strg.trim();
if (removeOuter) {
if (strg.startsWith(Character.toString(open))) {
strg = strg.substring(1);
}
if (strg.endsWith(Character.toString(close))) {
strg = strg.substring(0,
strg.lastIndexOf(Character.toString(close)));
}
}
list.add(strg); // + Character.toString(close));
}
// (red(blue))grey((orange)green)
return list.toArray(new String[list.size()]);
}