Question

我遇到了一个问题，我需要在char数组中找到子字符串，并且必须计算该子字符串出现了多少次。例如：“ aabbcccddaabbbccc” O / P：氨基酸：2 bb：1 抄送：2 dd：1 bbb：1

我尝试了这段代码，但是如果有人可以告诉我我做错了什么，它并不能给我适当的解决方法

public class CountSubString {
     static Set set=new HashSet<>();
     static List list=new ArrayList<>();


    private static Map<char[], Integer> count(char[] charArrayToParse){
        Map<char[], Integer> subString = new HashMap<char[], Integer>();

        for (int i=0; i<charArrayToParse.length ;)
        {StringBuilder word= new StringBuilder();
            for (int j=i; j<charArrayToParse.length; j++) {

                if(charArrayToParse[i] == charArrayToParse[j]) {
                    word.append(charArrayToParse[j]);
                }
                else {
                    char[] subStringDone = word.toString().toCharArray();
                    if(subString.isEmpty())
                    subString.put(subStringDone, 1);

                    else if(subString.containsKey(subStringDone)) {
                        subString.put(subStringDone, subString.get(subStringDone)+1);
                    }
                    else {
                        subString.put(subStringDone, 1);
                    }

                //System.out.println("Word value are"+subString.get(key));
                    i=j;
                break;
                }

            }

        }
        Set<char[]> keyValues=  subString.keySet();
        for(char[] ch : keyValues) {
            if(subString.get(ch)>1) {
                 System.out.println(ch+"--->"+subString.get(ch));
            }
        }
        return subString;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str = "aaabbbccddddaaaeebbb"; 
        char[] charArray = str.toCharArray();
        Map<char[], Integer> parsedArray= new HashMap<char[], Integer>();
    parsedArray= count(charArray);
    }

}

Answer 1

由于这看起来像是一项家庭作业，因此我不会发布代码解决方案，但会为您指明正确的方向。

您的double for循环正在创建一个无限循环。您正在设置i = j，但设置得不够高而无法跳出循环（永远不会超过17）。在我的书中嵌套的for循环通常是代码的味道，您应该将其分解为更多的功能（低内聚性）。

在这种情况下，您的第一个功能应该是将字符串分解为模式。您可以将嵌套的for循环简化为一个循环，并且每次找到模式时，请将其添加到Set<String>而不是映射中。这将防止重复，因为Set只能包含唯一值。

然后您可以继续进行下一部分以确定模式计数。请记住，在这种情况下，请遍历字符串并检查是否匹配。计算时，您需要考虑到aa也将与aaa相匹配。

Answer 2

可以使用库吗？如果是这样，则StringUtils中有apache.commons.lang3可以单行解决问题，如下所示：

int count = StringUtils.countMatches("aabbcccddaabbbccc", "aa");

Answer 3

要考虑的事情.. bbaaarr有两个aa序列还是一个序列？我的解决方案认为有两个，但是可以针对其他情况轻松进行调整。

我的代码中的注释有助于对其进行解释：

/**
 * Returns the number of times the sequence occurs in the string.
 * @param seq - the sequence you are looking for
 * @param str - the string you are searching in
 */
private static int count(String seq, String str) {
    if(seq == null || seq.isEmpty() ||
       str == null || str.isEmpty() ){
        return 0;
    }
    int count = 0;

    // the first character of the sequence you are looking for
    final char seqChar = seq.charAt(0);

    // if there aren't seq.length() chars remaining then
    // it's no longer possible to match your sequence
    // so this is the max index to go to when looking for it
    final int maxIndex = str.length() - seq.length();

    // iterate through the characters in your string
    for (int i = 0; i <= maxIndex; i++) {
        // when you find a character matching the start of your sequence
        // then compare the substring of equal length to your sequence
        // and if it matches then you have a match
        if (seqChar == str.charAt(i) &&
            seq.equals(str.substring(i, i + seq.length()))) {
            count++;
        }
    }
    return count;
}

public static void main(String[] args){
    String s = "aabbcccddaabbbccc";
    System.out.println(count("aa", s)); // 2
    // [aa]bbcccddaabbbccc
    // aabbcccdd[aa]bbbccc

    System.out.println(count("bb", s)); // 3
    // aa[bb]cccddaabbbccc
    // aabbcccddaa[bb]bccc
    // aabbcccddaab[bbccc

    System.out.println(count("cc", s)); // 4
    // aabb[cc]cddaabbbccc
    // aabbc[cc]ddaabbbccc
    // aabbcccddaabbb[cc]c
    // aabbcccddaabbbc[cc] 
}

如何使用Java查找字符串中的子字符串并获得其计数

3 个答案: