检查字符串

Question

我需要建立一个方法来检查，如果一个字符串具有以下格式的格式：

[{...},{...},...,{...}]

但我不知道什么是做到这一点的最佳/更简单的方法。我应该迭代字符串还是可以使用Pattern/Matcher类？

一些建议或代码的一开始将不胜感激。

编辑

的问题是，该字符串可以来错了格式，因此该方法返回前人的精力错误......接下来，我将展示一些例子，什么可以来和应返回什么：

[{...},{...},{...}] - > return VALID;

[{...},{...}] - > return VALID;

[{...},{...},{...},{...}] - > return VALID;

[...},{...},{...},{...}] - > return ERROR;

[{...},{...}{...}] - > return ERROR;

[{...},{...},{...},{...} - > return ERROR;

[{...,{...},{...},{...}] - > return ERROR;

[{...},{...},,{...}] - > return ERROR;

[asd{...},{...},{...},{...}] - > return ERROR;

Answer 1

EDITED反映表示不包含任意串点“[”，“]”或“{”

String regex = "\\[\\{[^\\[\\]{]*}(,\\{[^\\[\\]{]*})*]"; 

如果这看起来令人望而生畏，这可能是由于更多为Java String字符逃避比正则表达式本身。没有所有的逃逸（必需的）它看起来像：

\[\{[^\[\]{]*}(,\{[^\[\]{]*})*] 

以及由空格分隔的逻辑分组更加明确：

\[ \{[^\[\]{]*} (,\{[^\[\]{]*})* ] 

第一个和最后一个字符是开放的字面匹配/关闭'['和']'。第二个字符表示所需的开放字面值'{'，后面跟着一个字符类表达式，表示一个字符串表达式，表示除['，']'或'{'之外的任意字符数（零个或多个），最后是源字符串中第一个花括号分组的关闭字面值'}'。

然而，有可能是附加的花括弧分组之后，所以括号表达式重复的第一个与前面的文字逗号，和此整个表达式可以重复零次或多次。

所以，如果这使得任何更容易阅读和维护，你可以在代码如下表达出来：

String subgrp = "\\{[^\\[\\]{]*}"; 
String optionalRepeatSubgrp = "(," + subgrp + ")*"; 

String regex = "\\[" + subgrp + optionalRepeatSubgrp + "]"; 

Answer 2

这似乎但是解决大部分的问题，因为我在负不太好先行我无法破解失败下面

此代码的唯一情况

1. Recursilvely替换{*},图案与空字符串
2. 然后用空字符串替换上一个{*}
3. 其余的如果与[]匹配，则该字符串被认为是有效的或不是。

希望你得到我想要做的。

public static boolean isValid(String input){ 

     // Iterates and replaces all but one substring that match {...}, 
     boolean replaced = true; 
     int oldLength=0, newLength=0; 
     while(replaced){ 
      oldLength=input.length(); 
      input = input.replaceFirst("\\{[a-z.]+},", ""); 
      newLength=input.length(); 
      if(oldLength==newLength) replaced=false; 
     } 

     // Replaces the last {...} 
     // This one is done separately as comma should not be present in the last part 
     input = input.replaceFirst("\\{.*?}", ""); 

     //Then if the string remaining is just [] then it is valid 
     if(input.equals("[]")){ 
      return true; 
     } else { 
      return false; 
     } 
    } 

    public static void main(String[] args) { 
     String[] input = {"[{...},{...},{...}]", 
          "[{...},{...}]", 
          "[{...},{...},{...},{...}]", 
          "[...},{...},{...},{...}]", 
          "[{...},{...}{...}]", 
          "[{...},{...},{...},{...}", 
          "[{...,{...},{...},{...}]", 
          "[{...},{...},,{...}]", 
          "[asd{...},{...},{...},{...}]" 
        }; 
     for (String s : input) { 
      if(isValid(s)){ 
       System.out.println("VALID"); 
      } else { 
       System.out.println("ERROR"); 
      } 
     } 
    } 
} 

此输出 -

VALID 
VALID 
VALID 
ERROR 
ERROR 
ERROR 
VALID 
ERROR 
ERROR 

所以它没有被正确地处理，即第三个最后一种情况

[{...,{...},{...},{...}] 

这确实需要即正则表达式的负先行{*},不应该匹配{如果它出现在{之后和}之前。

Answer 3

为什么不迭代字符串，而不是花时间思考复杂的正则表达式？

public boolean isValid(String str){ 
     if(!str.startsWith("[") || !str.endsWith("]")) 
      return false; 

     if(1 < str.length() - 2) 
      return false; 

     str = str.substring(1, str.length() - 2); 

     String[] array = str.split(","); 
     String part; 

     for(int i = 0 ; i < array.length ; i ++){ 
      part = array[i]; 

      if(!part.startsWith("{") || !part.endsWith("}")) 
       return false; 

      if(1 < part.length() - 2) 
       return false; 

      part = part.substring(1, part.length() - 2); 

      if(part.contains("{") || part.contains("}")) 
       return false; 
     } 

     return true; 
    }