英文:
How to process a line in Java?
问题
以下是翻译好的部分：
问题中所涉及的行的格式如下：
1:{O:{o1,巴西,F1,G2,E1},N:{n1,阿尔巴尼亚,D2,V2,R2,E1,A2}}
问题是，我使用了 split("","")，然后我有两个字符串，我需要从每个字符串中创建一个具有所述属性的对象。我如何读取每个属性并在其相应的位置使用它们？
英文:
The format of line in question is:
1:{O:{o1,Brasil,F1,G2,E1},N:{n1,Albania,D2,V2,R2,E1,A2}}
The thing is, I use the split(",") and I have two strings and from each of them I have to create an object with said attributes. How can I read each one of the attributes and use them in its corresponding place?
答案1
得分: 0
以下是您提供的内容的翻译部分：
为了实现这一点，我提供了两种特定的方法，除了这个特定的任务，它们还可以用于其他事情。
第一个方法是 bracketsMaxDepth() 方法，它返回特定嵌套括号的深度。支持的括号类型为 (), [], {}, <>。您感兴趣的是花括号（ { } ）。
第二个方法是 getNestedBracketedGroups() 方法，它将解析括号字符串中嵌套括号组的内容（提取），并将这些组的内容返回到单维字符串数组中。支持的括号类型为 (), [], {}, <>。您感兴趣的是花括号（ { } ）。
getNestedBracketedGroups() 方法内部使用了 bracketsMaxDepth() 方法。例如，要解析以下字符串：
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();// 获取玩家编号String player = line.substring(0, line.indexOf(":"));// 玩家是一个整数表示的字符串吗？if (!player.matches("\\d+")) {// 不是的话...退出return; // 或者使用您需要的其他退出机制。}int playerNumber = Integer.parseInt(player);// 获取玩家的生物...String[] playerCreatures = getNestedBracketedGroups(line, 1, "{}",true)[0].split(",(?![^\\{\\}]*\\})");// 显示生物数据System.out.println("玩家 #" + playerNumber);for (int i = 0; i < playerCreatures.length; i++) {String creat = playerCreatures[i];int creatureNumber = i + 1;String creatureType= creat.substring(0, creat.indexOf(":"));// 获取生物属性String[] creatureAttributes = creat.substring((creatureType + ":").length() + 1,creat.length() - 1).split("\\s{0,},\\s{0,}");System.out.println("\t生物 #" + creatureNumber);System.out.println("\t\t生物类型: " + creatureType);for (int j = 0; j < creatureAttributes.length; j++) {System.out.println("\t\t\t属性 #" + (j + 1) + ": " + creatureAttributes[j]);}}
在控制台窗口中解析的输出将如下所示：
玩家 #1生物 #1生物类型: O属性 #1: o1属性 #2: Brasil属性 #3: F1属性 #4: G2属性 #5: E1生物 #2生物类型: G属性 #1: g1属性 #2: Germany属性 #3: D2属性 #4: V2属性 #5: F1属性 #6: G2属性 #7: E1生物 #3生物类型: N属性 #1: n1属性 #2: Albania属性 #3: D2属性 #4: V2属性 #5: R2属性 #6: E1属性 #7: A2
bracketsMaxDepth() 方法：
/*** 该方法接受一个字符串并返回嵌套括号的最大深度。要检查深度的括号类型在 bracketType 参数中提供。<br><br>** @param bracketedString (String) 要处理的字符串。<br>** @param bracketType (String - 默认为 "()"）可以提供一个开括号、闭括号，或者同时提供开括号和闭括号（无空格）。此方法将处理 4 种不同的括号类型之一，它们如下：<pre>** () 圆括号 （默认）* {} 花括号* [] 方括号* <> 尖括号</pre>** @return (Integer) 提供的括号类型的最大深度。如果提供的字符串中没有所提供类型的括号，则返回 0。如果所提供类型的字符串内存在不平衡，返回 -1。对于每个开括号，必须有一个闭括号，反之亦然。*/public static int bracketsMaxDepth(String bracketedString, String... bracketType) {// 方法实现，已略过...}
getNestedBracketedGroups() 方法：
/*** 该方法将解析括号字符串中嵌套括号组的内容（提取），并将这些组的内容返回到 1D 字符串数组中。** @param bracketedString (String) 包含要解析的括号内容的字符串。<br>** @param desiredDepth (Integer) 默认为 0（完整深度）。要从中检索括号内容的嵌套深度。<br>* 如果所提供的括号深度比所提供的输入字符串中包含的深度更深，则会抛出 IllegalArgumentException 异常，说明情况如此。** @param bracketType (String) 您必须提供要处理的括号类型。可以通过提供单个开括号或闭括号，或者同时提供开括号和闭括号来实现。例如，如果需要圆括号，则以下所有条<details><summary>英文:</summary>To do this I provide two specific methods which can be useful for other things other than this particular task.The first method is the **bracketsMaxDepth()** method which returns the the depth of a particular nested bracket. Supported brackets are `(), [], {}, <>`. The brackets you're interest in are the curly braces ( **{ }** ).The second method is the **getNestedBracketedGroups()** method which will parse out (retrieve) the contents of nested brackets groups within a bracketed string and return those group contents within a Single Dimensional (1D) String Array. Supported brackets are `(), [], {}, <>`. The brackets you're interest in are the curly braces ( **{ }** ).The **bracketsMaxDepth()** method is used internally by the **getNestedBracketedGroups()** method. As an example, to parse out the the following string: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}}";we might do something like this (I added an extra creature for testing):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 NumberString player = line.substring(0, line.indexOf(":"));// Is the player a string representation of a integer number?if (!player.matches("\\d+")) {// Nope...exitreturn; // 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 dataSystem.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 AttributesString[] 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]);}}The parsed output to Console Window would look like:Creatures for Player #1Creature #1Creature Type: OAttribute #1: o1Attribute #2: BrasilAttribute #3: F1Attribute #4: G2Attribute #5: E1Creature #2Creature Type: GAttribute #1: g1Attribute #2: GermanyAttribute #3: D2Attribute #4: V2Attribute #5: F1Attribute #6: G2Attribute #7: E1Creature #3Creature Type: NAttribute #1: n1Attribute #2: AlbaniaAttribute #3: D2Attribute #4: V2Attribute #5: R2Attribute #6: E1Attribute #7: A2----------> The **bracketsMaxDepth()** method:/*** 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* &lt;&gt; 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 = '('; // Defaultchar close = ')'; // Defaultif (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 countint max = 0; // overall maximum countint n = bracketedString.length();char[] c = bracketedString.toCharArray();// Traverse the input stringfor (int i = 0; i < n; i++) {if (c[i] == open) {current_max++;// update max if requiredif (current_max > max) {max = current_max;}}else if (c[i] == close) {if (current_max > 0) {current_max--;}else {return -1;}}}// finally check for unbalanced stringif (current_max != 0) {return -1;}return max;}----------> The **getNestedBracketedGroups()** method:/*** 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* &lt;&gt; 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 = '('; // Defaultchar close = ')'; // DefaultString 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()]);}</details>
通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库，让每个人都能够通过互相帮助和分享经验来进步。
评论