Java 字符串上的正则表达式，用于匹配和不考虑顺序的匹配

我正在编写一个Java程序，一次搜索15个字符的DNA序列，找到C和G出现次数最多的部分。我认为检查整个DNA序列最快的方法是检查15个子串完全由C和G组成的任何区域，如果这些区域不存在，寻找具有14个C和G以及1个A或T的子串。如果没有出现，13个CG和2个AT，等等

事实证明，为这个问题找到一个正则表达式解决方案对我来说很困难。我已经用这段代码设计了一个测试用例，但是我无法让正则表达式工作。我认为语法可能是错误的，我从未在Java中使用过正则表达式。很抱歉，我可能可以找到语法，我只需要帮助正则表达式本身匹配正确的东西

public class DNAChecker{

     public static void main(String []args){
        String checkThis= "ggccggccaggccgg";

        if (checkThis.matches( “(?=.*[CcGg]{14})(?=.*[AaTt]{1})” ) ) {
            System.out.println("This program works.");
        } else {
            System.out.println("This program doesn't work.");
        }
     }
}

根据我对它的理解，以及我在相关线程中看到的情况，如果这可以用正则表达式来完成，那么我至少已经接近了这一点。现在我在考虑这个问题，我不认为这可以确保总匹配长度为15个字符。。。i、 e.如果检查长度超过15个字符，并且总共有14个CG和1个CG，而不是连续的，那么这仍然是正确的。所以xxxxggccggxxccagccggxxxxxx是真的。使用.contains而不是.matches可以确保长度限制吗

无论如何，像这样的一行正则表达式会比计算每个子字符串的C和G更快吗？我还没有上过算法课

请记住，此最终形式的程序将接受一个可变长度的字符串，并搜索长度为n的子字符串，而不是每次搜索15个。（我知道如何处理这些要求，因此无需告诉我Scanner或参数如何工作！）我只是一个试图使用绝地级正则表达式的正则表达式noob。。。如果你能推荐一本书让我也成为正则表达式的向导，那就太激进了。

---

非常感谢您的回复

正则表达式是任何语言中最诱人的特性之一。然而，仅仅因为它们很酷、性感、看起来很强大并不意味着它们是正确的工具。对于这种情况，一个简单的状态机就足够了，而且速度可能会快得多。下面的代码查找仅包含

c

和

g

的最长子字符串，通过将它们添加到一个集合中，可以轻松调整以保留多个子字符串

    String data = "acgtcgcgagagagggggcccataatggg";
    int    longestPos = 0;
    int    longestLen = 0;
    int p=-1;
    for (int i=0; i<data.length(); i++)
    {
        char c = data.charAt(i);
        if (c == 'c' || c == 'g')  // Is this the droid you're looking for?
        {
            if (p==-1)  // Are we not yet in an interesting string?
                p = i;  // If so, save the position of this start of substring.
        }
        else  // Not a c or g
        {
            if (p != -1 && i-p > longestLen)  // Are we in an interesting string longer than the previous longest?
            {
                longestPos = p;     // Save the starting position
                longestLen = i-p;   // Save the length
            }
            p = -1;   // We're no longer inside an interesting string
        }
    }

    // Handle the case where the last substring was 'interesting'
    if (p != -1 && i-p > longestLen)
    {
        longestPos = p;     // Save the starting position
        longestLen = i-p;   // Save the length
    }

    System.out.printf("Longest string is at position %d for length %d", longestPos, longestLen);

String data=“acgtcggagagggggccataggg”；
int longestPos=0；
int longestLen=0；
int p=-1；
for（int i=0；i longestLen）
{
longestPos=p；//保存起始位置
longestLen=i-p；//保存长度
}
System.out.printf（“长度为%d的最长字符串位于位置%d”，longestPos，longestLen）；

---

对于“让我们在不适用的地方使用正则表达式”的规范响应，请参见

我不完全确定是否正确理解了您的问题，因此我假设您希望找到由

c

s和

g

s，然后是

a

或

t

组成的最长字符序列

我进一步假设您的输入字符串只包含这些字符

因此，您可以尝试使用

Pattern.compile（regex）.matcher（input）.find（）

来获取所有匹配的组。然后按长度排序，得到最长的序列

为了实现这一点，您可以使用以下正则表达式：

（？i）（[cg]+[at]）

（

（i？

使表达式不区分大小写）

例如：

String input = "ccgccgCggatccgCATccggcccgggggtatt";

List<String> sequences = new ArrayList<>();

//find the sequences
Matcher m = Pattern.compile("(?i)([cg]+[at])").matcher( input );
while( m.find() ) {
  sequences.add( m.group().toLowerCase() );
}

//sort by descending length
Collections.sort( sequences, new Comparator<String>() {
  public int compare( String lhs, String rhs ) {
    //switch arguments for descending sort
    return Integer.compare( rhs.length(), lhs.length());
  }
});

System.out.println( sequences );

String input=“CCGCCGGATCGCATCCGGCCCGGGTATT”；
列表序列=新的ArrayList（）；
//找到序列
Matcher m=Pattern.compile（“（？i）（[cg]+[at]）”）.Matcher（输入）；
while（m.find（））{
sequences.add（m.group（）.toLowerCase（））；
}
//按降序长度排序
排序（序列，新的比较器（）{
公共整数比较（字符串lhs、字符串rhs）{
//用于降序排序的开关参数
返回整数.compare（rhs.length（），lhs.length（））；
}
});
System.out.println（序列）；

输出为：

[CCGGCCCGGGT，CCGCCGGA，ccgca]

---

如果希望只允许这些序列的特定长度，则需要修改正则表达式：

（？i）（？我担心正则表达式在这个问题上对您可能不会太有用。我建议您只计算字符串中
c
s和
g
s的数量，而不是有关正则表达式的信息/教程，请尝试以下网站：和！您能提供一些输入字符串的示例以及您想要得到的内容吗？如果我正确地理解您，您有一个相当大的输入字符串，并且查找最多由15个字符组成的序列，这些字符仅由
c
和
g
组成，结尾是
a
或
t
。这正确吗？需要记住的一点是执行
字符串匹配（regex）之间的区别
并执行
Pattern.compile（regex）.matcher（String）.find（）
。前者查找精确匹配，后者只查找regex作为原始输入的子字符串。因此，在您的情况下，您可能需要使用
Pattern.compile（regex）.matcher（String）.find（）
确定正则表达式是否与输入的任何子字符串匹配。