Question

任务

名为getKey1（）的函数应该返回在字符串中出现最大次数的子字符串。

我做了什么？

public class Proc {
public static String getKey1(String str)
{
    LinkedList link = new LinkedList();
    int i = 0;
    int t = 0;
    String pattern = "";
    l1:
    while(i < str.length())
    {
        if(str.charAt(i) != ' ')
        {
            t = i;
            for(t = i; t < str.length(); t++)
            {
                if(str.charAt(t) == ' ')
                    break;
                else if( t >= str.length())
                    break l1;
            }
            pattern = str.substring(i, t);
            link.add(pattern);
            i += pattern.length();
        }
        else
            i++;
    }


    LinkedList link2 = new LinkedList();
    LinkedList link3 = new LinkedList();
    Iterator f = link.iterator();

    while(f.hasNext())
    {
        Object o = f.next();
        String ss = (String)o;
        if(link3.contains(o))
        {
            Iterator m = link2.iterator();
            while(m.hasNext())
            {
                Object ro = m.next();
                struct sto = (struct)ro;
                String so = sto.str;
                if(so.equals(ss))
                {
                    sto.count++;
                }
            }
        }
        else
        {
            link3.add(ss);
            link2.add(new struct(ss, 1));
        }
    }

        Iterator k = link2.iterator();
        struct min = new struct("a", 10);

        while(k.hasNext())
        {
            Object ost = k.next();
            struct spt = (struct)ost;
            System.out.println(spt.str + "  " + spt.count);
            if(spt.count > min.count);
            {
                min.str = spt.str;
                min.count = spt.count;
            }
        }
    return min.str;
    }
}

struct class：

public class struct {
public int count;
public String str;
public struct(String str, int count)
{
    this.str = str;
    this.count = count;
}

}

主要班级：

public class Asdf {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    System.out.println(Proc.getKey1("This is a string. boom boom kaboom boom"));
}

}

输出

This  1

is  1

a  1

string  1

boom  3

kaboom  1


kaboom

问题

这实际上是一个测试运行，显示字符串str中出现子串的次数。所以根据这个输出，＆＃34;繁荣＆＃34;应该归还给主，但是＆＃34; kaboom＆＃34;退回。经过进一步的测试，我得出结论，在最后一个if语句中存在问题： if（spt.count＆gt; min.count）看起来好像程序总是进入这个if语句，无论如何。我改成了如果（4 <3）并且仍然有相同的输出。

Answer 1

如果计算结果为true，那么if(spt.count > min.count);所做的就是执行空语句;。总是执行此行之后的括号中的位。

我确信不打算控制流程。

另外，请考虑远离break label;反模式进行重构。它使代码变得脆弱：太容易意外移动标签而忘记某人break依赖于其精确位置。

Answer 2

你有一个“;”在你的IF线的末尾。

if(spt.count > min.count);

Answer 3

Memran回答了你的具体问题 - “if”下方的块无条件运行，因为分号结束了if而块只是一个块。

然而，除非我误解了你在这里要做的事情，否则坦率地说你的问题最少： - ）

看起来当你说“substring”时，你的意思是“空格分隔的令牌”。假设是这种情况，这里有一个很好的直接方式来分割单词，计算它们，然后寻找最大的计数：

String input = "foo bar baz quux quux bar baz foo bar wibble";
List<String> words = Arrays.asList(input.split(" "));

Map<String, Integer> counts = new HashMap<String, Integer>();

for (String word : words) 
{
    Integer count = counts.get(word);
    count = (count == null? 1 : count+1);
    counts.put(word, count);
}

int max = 0;
String maxWord = null;
for (String word : counts.keySet()) 
{
    Integer count = counts.get(word);
    if(count > max) 
    {
        max = count;
        maxWord = word;
    }
}

System.out.println("Most-used word is "+maxWord+" with "+max+" uses.");

我确信如果性能很重要，还有更聪明的方法可以做到这一点。但通常简单明了会更好。

如果语句不在字符串搜索中工作

3 个答案: