Java 有没有办法指定一个不使用'；你和其他人都不匹配吗？

假设我有这样的东西：

    pattern = new Pattern[6];
    pattern[0] = Pattern.compile("^\\s*(NAME\\:\\s*)\\s(\\w+)");
    pattern[1] = Pattern.compile("^\\s*(AGE\\:\\s*)\\s(\\d+)");
    pattern[2] = Pattern.compile("^\\s*(ADDRESS\\:\\s)(\\w+)");
    pattern[3] = Pattern.compile("^\\s*(BIRTHDAY\\:\\s)(\\d+)\\:(\\d+)\\:(\\d+)");        
    pattern[4] = Pattern.compile("(?=\\s*\\*)(^\\**)");
    pattern[5] = Pattern.compile("\\S+|[^\\s*.+\\s*]");

public boolean lookAhead (int a) {
        Pattern error = Pattern.compile("^[^(\\s*NAME.*)(\\s*AGE.*)(\\s*ADDRESS.*)(\\s*BIRTHDAY.*)]");
        Pattern legit = Pattern.compile("^[(\\s*NAME.*)(\\s*AGE.*)(\\s*ADDRESS.*)(\\s*BIRTHDAY.*)");
        while ((line = buff.readLine()) != null) {                                
                 Matcher comment = pattern[4].matcher(line);
                 Matcher err = error.matcher(line);
                 Matcher leg = legit.matcher(line);
                 Matcher name = pattern[0].matcher(line);
                 Matcher age = pattern[1].matcher(line);
                 Matcher addr = pattern[2].matcher(line);
                 Matcher bd = pattern[3].matcher(line);
                 Matcher input = pattern[a].matcher(line);
                 if (!input.find() && (comment.find() || err.find() || (leg.find() && (!name.find() && !age.find() && !addr.find() && !bd.find())))               
                     continue;
                    Matcher dp = pattern[a].matcher(line);
                    dpla = dp.find();
                    break;
                 }
        }
        return dpla;
     }

模式4的要点是捕获后跟*的注释，模式5是捕获其他模式无法捕获的所有内容。然后Matcher dp检查该模式是否是从返回true或false的前瞻中预期的模式

    public boolean lookAhead () {
        while ((line = buff.readLine()) != null) {
                 Pattern different = Pattern.compile("^[^(\\s*NAME.*)(\\s*AGE.*)(\\s*ADDRESS.*)(\\s*BIRTHDAY.*)]");                
                 Matcher comment = pattern[4].matcher(line);
                 Matcher diff = different.matcher(line);
                 Matcher name = pattern[0].matcher(line);
                 if (comment.find() || different.find() /*|| name.find()*/)               
                     continue;
                    Matcher dp = pattern[0].matcher(line);
                    dpla = dp.find();
                    break;
                 }
        }
        return dpla;
     }

---

注释被忽略，所有随机错误，如：“feifeijfie”也将被忽略。但是，如果文本类似于“名称7987997 GSGE 456”，则应将其视为错误，但事实并非如此。如果name.find未注释，它将始终工作，但它不会返回false。

让我们简单地使用一些不同的方法。我认为，本质上，你有一些输入字符串；然后你有一个不同正则表达式的列表，其中可能包含你感兴趣的匹配器。您在代码中进行了大量匹配，最终只返回一个布尔值；这似乎没什么用；所以我要给你一个想法，如何做不同的事情

 class RegexListMatcher {
   private final Map<String, Pattern> patternsById;
   private final String inputToMatchOn;

   private final String matchingId;
   private final String matchResult;

   RegexListMatcher(Map<String, Pattern> patternsById, inputToMatchOn) {
     this.patterns... = patterns
     this.input... = input

     matchingId = findMatchingId();
     if (matchingId == null) {
        matchResult = null;
     } else {
        matchResult = getMatchResult();
     }
   }

   private final String findMatchingId() {
     for (Entry<String, Pattern> entry : patternsById) {
       if entry.value matches the given input return entry.key

     otherwise return null
   }

   private final String getMatchResult() {
     Pattern pattern = patternsById.get(matchingId);
     return the value matched within input 
   }

   public boolean hasMatch() { return matchingID != null; }
   public String getMatchId() ...
   public String getMatchResult() ...

类RegexListMatcher{
私人最终地图模式byid；
私有最终字符串inputtomachon；
私有最终字符串匹配ID；
私有最终字符串匹配结果；
RegexListMatcher（映射模式BYID，InputToMachon）{
这个。模式…=模式
this.input…=输入
matchingId=findMatchingId（）；
if（matchingId==null）{
matchResult=null；
}否则{
matchResult=getMatchResult（）；
}
}
私有最终字符串findMatchingId（）{
for（条目：patternsbyd）{
如果entry.value与给定的输入匹配，则返回entry.key
否则返回null
}
私有最终字符串getMatchResult（）{
Pattern Pattern=patternsbyd.get（matchingId）；
返回输入中匹配的值
}
公共布尔hasMatch（）{return matchingID！=null；}
公共字符串getMatchId（）。。。
公共字符串getMatchResult（）。。。

要像这样使用：

 private final static Map<String, Pattern> RULES = new HashMap<>();
 RULES.put("NAME", Pattern.compile("^\\s*(NAME\\:\\s*)\\s(\\w+)"));
 ...

 RegexListMatcher listMatcher = new RegexListMatcher(RULES, someInputString);
 if (listMatcher.hasMatch()) { 
   one of the rules matched
 } else {
   no match at all
 }

private final static Map RULES=new HashMap（）；
RULES.put（“NAME”，Pattern.compile（“^\\s*（NAME\\：\\s*）\\s（\\w+）））；
...
RegexListMatcher listMatcher=新的RegexListMatcher（规则，someInputString）；
if（listMatcher.hasMatch（））{
其中一条规则是一致的
}否则{
根本没有对手
}

我的实现中的关键点是：您有一个潜在模式的列表；如果其中一个匹配，您肯定对输入中匹配的值感兴趣。令人惊讶的是：如果没有匹配的模式，那么您也知道这一点。因为RegexListMatcher可以告诉您

---

当然，代码比您的要多；但例如：对某个数组索引根本没有任何硬编码访问。显然，上面的部分是伪代码，但我想它应该足以让您开始使用。

我今天能够解决这个问题！如果我没有很好地解释我的问题，我很抱歉，因为我必须弥补我的问题gex试图解释这个问题，也许我错过了一些重要的要点来获得一个好的答案。与我所拥有的相比，这是一段非常简化的代码。主要问题是，尽管注释和所有不是模式的内容（模式“错误”否定了所有从其他模式开始的内容）将被检测到并将继续While循环，如果模式以NAME:或AGE:等开头，这意味着它将不同于“error”模式，因此它不会继续循环，但这不应该发生，因为它只应在检测到有效模式时停止循环。因此我所做的是：

Pattern legit = Pattern.compile("^[(\\s*NAME.*)(\\s*AGE.*)(\\s*ADDRESS.*)(\\s*BIRTHDAY.*)");
Matcher leg = legit.matcher(line);

此模式的要点是确定在注释和错误失败的情况下可能出现的情况。如果出现，则需要检查有效的注释和错误是否失败：

(leg.find() && (!name.find() && !age.find() && !addr.find() && !bd.find())))

您可以通过参数处的int选择要查找的模式，该模式将更改：

Matcher input = pattern[a].matcher(line);
                 if (!input.find() ...)

因此，所有的组合都是这样的：

    pattern = new Pattern[6];
    pattern[0] = Pattern.compile("^\\s*(NAME\\:\\s*)\\s(\\w+)");
    pattern[1] = Pattern.compile("^\\s*(AGE\\:\\s*)\\s(\\d+)");
    pattern[2] = Pattern.compile("^\\s*(ADDRESS\\:\\s)(\\w+)");
    pattern[3] = Pattern.compile("^\\s*(BIRTHDAY\\:\\s)(\\d+)\\:(\\d+)\\:(\\d+)");        
    pattern[4] = Pattern.compile("(?=\\s*\\*)(^\\**)");
    pattern[5] = Pattern.compile("\\S+|[^\\s*.+\\s*]");

public boolean lookAhead (int a) {
        Pattern error = Pattern.compile("^[^(\\s*NAME.*)(\\s*AGE.*)(\\s*ADDRESS.*)(\\s*BIRTHDAY.*)]");
        Pattern legit = Pattern.compile("^[(\\s*NAME.*)(\\s*AGE.*)(\\s*ADDRESS.*)(\\s*BIRTHDAY.*)");
        while ((line = buff.readLine()) != null) {                                
                 Matcher comment = pattern[4].matcher(line);
                 Matcher err = error.matcher(line);
                 Matcher leg = legit.matcher(line);
                 Matcher name = pattern[0].matcher(line);
                 Matcher age = pattern[1].matcher(line);
                 Matcher addr = pattern[2].matcher(line);
                 Matcher bd = pattern[3].matcher(line);
                 Matcher input = pattern[a].matcher(line);
                 if (!input.find() && (comment.find() || err.find() || (leg.find() && (!name.find() && !age.find() && !addr.find() && !bd.find())))               
                     continue;
                    Matcher dp = pattern[a].matcher(line);
                    dpla = dp.find();
                    break;
                 }
        }
        return dpla;
     }

---

就像我想要的那样工作：D

也许你还应该说你输入的有效变体是什么样子的；你的代码实际上应该做什么。我很难从你的正则表达式中推断出这种逻辑。这已经给了一点提示，也许你当前的代码不太容易阅读。意思是：我认为这里的解决方案通过专注于你真正想知道的关于你的输入的东西，你可以戏剧性地修改你的代码。因此：请澄清你的要求。

模式[4]

在我看来是错误的。它匹配“输入开始时的一个或多个星号”，并且大多数前瞻是毫无意义的；它相当于

“^\\*+”

记录在案：请让我知道我的回答是否对您有帮助；或者是否缺少什么…@GhostCat是的，谢谢您的回答，您的想法似乎很好，但是由于我现在已经做了这么多，我需要花很长时间来重组一切，我自己的问题在几个小时后就可以得到答案o、 请随意查看并告诉我您的想法，但我肯定会记住您对未来项目的想法。