从字符串中提取值的最佳方法，该字符串可以采用多种形式，并从Java中的.properties文件加载

我有一个ws.properties文件，其中有一个名为success.code的属性，它让我可以选择哪些HTTP状态成功代码（2xx），除了默认的200之外，我希望服务器也将其视为“成功”

这个想法是这样的：

Set<Integer> parseHttpCodesParam(String input);

如果我这样输入值：

success.code=201202203（用逗号分隔的值）

负责提取该值的代码部分应立即理解这是三个独立的代码，提取每一个代码并将其存储在列表或集合中，或

这其实很简单：

private Set<String[]> getSuccessCodes(HashMap<String, String> codes){
    Set<String[]> successCodes = new HashSet<>();
    String value;
    for (Map.Entry<String, String> entry : codes.entrySet()) {
        value = entry.getValue();
        if(!StringUtils.isEmpty(value))
            successCodes.add(value.split("\\s*,\\s*"));
    }
    return successCodes;
}

private Set getSuccessCodes（HashMap代码）{
Set successCodes=new HashSet（）；
字符串值；
对于（Map.Entry:codes.entrySet（））{
value=entry.getValue（）；
如果（！StringUtils.isEmpty（值））
successCodes.add（value.split（“\\s*，\\s*”）；
}
返回成功代码；
}

这里有点复杂：

我还想添加以下选项：

success.code=[202220]（两个值写在挂钩之间，用逗号分隔）

• [202，220]：当像这样写入值时，我希望上面的方法能够理解，我希望202和220之间的所有值都像第一个案例一样被提取、存储和返回

成功。代码=2**

• 这意味着所有以2开头的代码（从201到299）都应该存储在集合或列表中，并以该方法返回给我

成功。代码=[200205]，22*

• 这意味着我希望代码返回200到205之间的所有代码（所以200201202，…，2005）加上从220到220的代码

因此，根据我为成功代码输入的值，程序应该能够理解做什么以及从中返回什么

这是可以实现的吗

---

提前感谢

与其要求您的程序接受您定义的一些复杂语法，为什么不让框架做它自然做的事情呢

success.code=201202203

success.code.min=202
success.code.max=220

success.code.prefix=22

---

然后在您认为合适的代码中组合这些属性。这是实现你想要的最简单的方法。

首先，答案肯定是是的，它是可以实现的。解决方案是，您必须编写自己的解析器或小型解释器，以获取字符串并首先“编译”它，即检查它是否为有效输入（假设“[”的数量等于“]”的数量，并且在解析时“]”的数量在任何时候都不大于“]”的数量，即字符串“[…]”[”应声明为无效）。然后它将对其进行解释。您希望您的语言越灵活，您的解释程序就越复杂。很可能正则表达式不够。但一般来说，您需要编写一个具有以下签名的方法：

Set<Integer> parseHttpCodesParam(String input);

Set parseHttpCodesParam（字符串输入）；

您的实现将有几个规则

如何处理逗号分隔的整数值

如何处理[]中两个逗号分隔的数字

如何对待特殊字符如*

---

etc

如果您不介意再添加三种方法，这里有一种方法：

• 使用

  “\\s*，\\s*（？！[^\\[]*\]）”

  在每个逗号处拆分文件，除非括号中
• i在生成的数组上创建/流并映射每个元素，检查它是否包含

  [

  或

  *

• 如果包含

  [

  则使用

  [x，y]

  中的值生成

  IntStream.rangeClosed（x，y）

  ，并将其映射到字符串值
• 如果包含

  *

  则通过将

  *

  替换为

  0

  和

  9

  生成

  IntStream.rangeClosed（x00，x99）

  ，并将其映射到字符串值

比如：

private static Set<String[]> getSuccessCodes(HashMap<String, String> codes){
    Set<String[]> successCodes = new HashSet<>();
    String value;
    for (Map.Entry<String, String> entry : codes.entrySet()) {
        value = entry.getValue();
        if(!StringUtils.isEmpty(value))
            successCodes.add(parse(value));
    }
    return successCodes;
}
public static String[] parse(String val) {
    String[] parts = val.split("\\s*,\\s*(?![^\\[]*\\])");
    return Arrays.stream(parts)
          .map(e -> e.contains("[")? getRangeCodes(e): e.contains("*")? getWildCCodes(e): e)
          .collect(Collectors.joining(",")).split("\\s*,\\s*");
}
private static String getRangeCodes(String e) {
    e = e.substring(1, e.length()-1);
    return IntStream.rangeClosed(Integer.parseInt(e.split("\\s*,\\s*")[0]), Integer.parseInt(e.split("\\s*,\\s*")[1]))
            .mapToObj(i -> String.valueOf(i))
            .collect(Collectors.joining(","));
}

private static String getWildCCodes(String e) {
    return IntStream.rangeClosed(Integer.parseInt(e.replace('*', '0')), Integer.parseInt(e.replace('*', '9')))
            .mapToObj(i -> String.valueOf(i))
            .collect(Collectors.joining(","));
}

private static Set getSuccessCodes（HashMap代码）{
Set successCodes=new HashSet（）；
字符串值；
对于（Map.Entry:codes.entrySet（））{
value=entry.getValue（）；
如果（！StringUtils.isEmpty（值））
successCodes.add（解析（值））；
}
返回成功代码；
}
公共静态字符串[]解析（字符串val）{
字符串[]parts=val.split（“\\s*，\\s*（？！[^\\[]*\]）”；
返回数组.stream（部分）
.map（e->e.contains（“[”）？getRangeCodes（e）：e.contains（“*”）？getWildCCodes（e）：e）
.collect（收集器.连接（“，”）.split（\\s*，\\s*”）；
}
私有静态字符串getRangeCodes（字符串e）{
e=e.子串（1，e.长度（）-1）；
返回IntStream.rangeClosed（Integer.parseInt（e.split（\\s*，\\s*）[0]），Integer.parseInt（e.split（\\s*，\\s*）[1]））
.mapToObj（i->String.valueOf（i））
.collect（收集器。连接（“，”）；
}
私有静态字符串getWildCCodes（字符串e）{
返回IntStream.rangeClosed（Integer.parseInt（e.replace（'*'，'0'）），Integer.parseInt（e.replace（'*'，'9'））
.mapToObj（i->String.valueOf（i））
.collect（收集器。连接（“，”）；
}

通过以下方式进行测试：

public static void main(String[] args) { 
    HashMap<String, String> codes = new HashMap<>();
    codes.put("foo", "201, 202, 203");
    codes.put("bar", "[202, 220]");
    codes.put("baz", "2**");
    codes.put("doo", "[200, 205], 22*");
    codes.put("woo", "200, 201, 202, 203,[209, 214], 29*");

    Set<String[]> set = getSuccessCodes(codes);
    set.forEach(s -> {System.out.println(Arrays.toString(s));});
}

publicstaticvoidmain（字符串[]args）{
HashMap代码=新的HashMap（）；
代码.put（“foo”，“201202203”）；
代码。put（“条形，”[202，220]”；
代码。put（“baz”、“2**”）；
代码。put（“doo”、“[200205]、22*”；
代码.put（“woo”，“200201202203，[209214]，29*”；
Set Set=getSuccessCodes（代码）；
set.forEach（s->{System.out.println（Arrays.toString（s））；}）；
}

你可能需要用正则表达式分离每个用例，然后为每个用例应用逻辑。太棒了。太棒了。如果我能把你的评论翻上一千遍，我会的。它不仅优雅，而且