Java模式包含数组中的所有字符串

我想检查一个长字符串是否包含多个字符串

我正在尝试使用下面的命令

          String[] words = {"GAGGAG", "AGGAC"};
          Pattern pattern = Pattern.compile("GAGGAG|AGGAC");
          if(pattern.matcher("GAGGAGGTC").find()){
                 System.out.println("find");
          }else{
                 System.out.println("Not find");
          }

结果应该是找不到的 因为“gaggtc”包含“GAGGAG”，但不包含“AGGAC”

我如何给出从“或”到“和”的选项

还有一个选择

          String[] words = {"GAGGAG", "AGGAC"};
          Pattern pattern = Pattern.compile("GAGGAG|AGGAC");
          if(pattern.matcher("GAGGAGGAC").find()){
                 System.out.println("find");
          }else{
                 System.out.println("Not find");
          }        

这也是应该显示“找不到”的。 因为不允许有重叠部分。

---

“GAGGAG”和“AGGAC”是“gaggaac”中重叠的“AG”部分

将您的正则表达式更改为“and”操作符的正则表达式

---

将正则表达式更改为“and”运算符的此值

---

将正则表达式更改为“and”运算符的此值

---

将正则表达式更改为“and”运算符的此值

---

你不需要一个正则表达式

使用

String#contains

：

public boolean checkContainsAll(String sentence, String[] words) {
    for(String word : words) {
        if(!sentence.contains(word)) {
            return false;
        }
    }
    return true;
}

在您的示例中：

String[] words = {"GAGGAG", "AGGAC"};
String sentence = "GAGGAGGTC";
if(checkContainsAll(sentence, words)) {
    System.out.println("The sentence " + sentence + " contains all words");
} else {
    System.out.println("The sentence " + sentence +" does not contain all words.");
}

---

更新

为了检查是否存在重叠，在我的示例中，最简单的解决方案是删除给定句子中的单词，这样它们就不会出现在下一次检查中：

public boolean checkContainsAll(String sentence, String[] words) {
    for(String word : words) {
        if(!sentence.contains(word)) {
            return false;
        }
        sentence = sentence.replace(word, "");
    }
    return true;
}

---

你不需要一个正则表达式

使用

String#contains

：

public boolean checkContainsAll(String sentence, String[] words) {
    for(String word : words) {
        if(!sentence.contains(word)) {
            return false;
        }
    }
    return true;
}

在您的示例中：

String[] words = {"GAGGAG", "AGGAC"};
String sentence = "GAGGAGGTC";
if(checkContainsAll(sentence, words)) {
    System.out.println("The sentence " + sentence + " contains all words");
} else {
    System.out.println("The sentence " + sentence +" does not contain all words.");
}

---

更新

为了检查是否存在重叠，在我的示例中，最简单的解决方案是删除给定句子中的单词，这样它们就不会出现在下一次检查中：

public boolean checkContainsAll(String sentence, String[] words) {
    for(String word : words) {
        if(!sentence.contains(word)) {
            return false;
        }
        sentence = sentence.replace(word, "");
    }
    return true;
}

---

你不需要一个正则表达式

使用

String#contains

：

public boolean checkContainsAll(String sentence, String[] words) {
    for(String word : words) {
        if(!sentence.contains(word)) {
            return false;
        }
    }
    return true;
}

在您的示例中：

String[] words = {"GAGGAG", "AGGAC"};
String sentence = "GAGGAGGTC";
if(checkContainsAll(sentence, words)) {
    System.out.println("The sentence " + sentence + " contains all words");
} else {
    System.out.println("The sentence " + sentence +" does not contain all words.");
}

---

更新

为了检查是否存在重叠，在我的示例中，最简单的解决方案是删除给定句子中的单词，这样它们就不会出现在下一次检查中：

public boolean checkContainsAll(String sentence, String[] words) {
    for(String word : words) {
        if(!sentence.contains(word)) {
            return false;
        }
        sentence = sentence.replace(word, "");
    }
    return true;
}

---

你不需要一个正则表达式

使用

String#contains

：

public boolean checkContainsAll(String sentence, String[] words) {
    for(String word : words) {
        if(!sentence.contains(word)) {
            return false;
        }
    }
    return true;
}

在您的示例中：

String[] words = {"GAGGAG", "AGGAC"};
String sentence = "GAGGAGGTC";
if(checkContainsAll(sentence, words)) {
    System.out.println("The sentence " + sentence + " contains all words");
} else {
    System.out.println("The sentence " + sentence +" does not contain all words.");
}

---

更新

为了检查是否存在重叠，在我的示例中，最简单的解决方案是删除给定句子中的单词，这样它们就不会出现在下一次检查中：

public boolean checkContainsAll(String sentence, String[] words) {
    for(String word : words) {
        if(!sentence.contains(word)) {
            return false;
        }
        sentence = sentence.replace(word, "");
    }
    return true;
}

---

您必须使用如下所示的

交替操作
操作符

Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");

说明：

  Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   // Output: Not find


GAGGAG.*AGGAC
与
GAGGAG
加
*
之间出现的任何字符匹配，并且必须具有
AGGAC
子字符串

|
或运算符，使其匹配任何顺序

AGGAC
匹配AGGAC，
*
零个或多个字符加上
GAGGAG
字符串


示例1:

  Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   // Output: Not find

例2：

Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   
}    // Output: find

例3：

Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("AGGACFOOGAGGAG").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }  // Output: find

您必须使用如下所示的
交替
运算符
|

Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");

说明：

  Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   // Output: Not find


GAGGAG.*AGGAC
与
GAGGAG
加
*
之间出现的任何字符匹配，并且必须具有
AGGAC
子字符串

|
或运算符，使其匹配任何顺序

AGGAC
匹配AGGAC，
*
零个或多个字符加上
GAGGAG
字符串


示例1:

  Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   // Output: Not find

例2：

Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   
}    // Output: find

例3：

Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("AGGACFOOGAGGAG").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }  // Output: find

您必须使用如下所示的
交替
运算符
|

Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");

说明：

  Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   // Output: Not find


GAGGAG.*AGGAC
与
GAGGAG
加
*
之间出现的任何字符匹配，并且必须具有
AGGAC
子字符串

|
或运算符，使其匹配任何顺序

AGGAC
匹配AGGAC，
*
零个或多个字符加上
GAGGAG
字符串


示例1:

  Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   // Output: Not find

例2：

Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   
}    // Output: find

例3：

Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("AGGACFOOGAGGAG").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }  // Output: find

您必须使用如下所示的
交替
运算符
|

Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");

说明：

  Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   // Output: Not find


GAGGAG.*AGGAC
与
GAGGAG
加
*
之间出现的任何字符匹配，并且必须具有
AGGAC
子字符串

|
或运算符，使其匹配任何顺序

AGGAC
匹配AGGAC，
*
零个或多个字符加上
GAGGAG
字符串


示例1:

  Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   // Output: Not find

例2：

Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("GAGGAGAGGAC").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }   
}    // Output: find

例3：

Pattern pattern = Pattern.compile("GAGGAG.*AGGAC|AGGAC.*GAGGAG");
  if(pattern.matcher("AGGACFOOGAGGAG").find()){
         System.out.println("find");
  }else{
         System.out.println("Not find");
  }  // Output: find

你必须使用正则表达式吗？使用
contains
要简单得多。这可能有助于您使用正则表达式吗？使用
contains
要简单得多。这可能有助于您使用正则表达式吗？使用
contains
要简单得多。这可能有助于您使用正则表达式吗？使用
contains
要简单得多。这可能会对您有所帮助。我真的很抱歉，这很好，但我忘了提及，因为乞讨不允许重叠部分。我的意思是句子“gaggtc”不允许，因为有重叠部分。但“GAGGAGNNNAGGAC”允许，因为它不重叠我真的很抱歉，这很好，但我忘了提到，因为乞讨不允许重叠部分。我的意思是句子“gaggagtc”不允许，因为有重叠部分。但“GAGGAGNNNAGGAC”允许，因为它不重叠我真的很抱歉，这很好，但我忘了提到，因为乞讨不允许重叠部分。我的意思是句子“gaggagtc”不允许，因为有重叠部分。但“GAGGAGNNNAGGAC”允许，因为它不重叠我真的很抱歉，这很好，但我忘了提到，因为乞讨不允许重叠部分。我的意思是句子“gaggagtc”不允许，因为有重叠部分。但是“gagnnnagac”允许，因为它没有重叠