Question

我正在尝试返回对象在对象数组中出现的位置的索引。

public static int search(WordCount[] list,WordCount word, int n)
{
    int result = -1;
    int i=0;
    while (result < 0 && i < n)
    {
        if (word.equals(list[i]))
        {
            result = i;
            break;
        }
        i++;
    }
    return result;
}

WordCount[]是对象数组。

word是WordCount的实例。

n是WordCount[]

中的对象数量

它运行，但没有正确返回索引。任何和所有的帮助表示赞赏。谢谢你的时间。

CLASS

class WordCount
{
String word;
int count;
static boolean compareByWord;
public WordCount(String aWord)
{
    setWord(aWord);
    count = 1;
}
private void setWord(String theWord)
{
    word=theWord;
}
public void increment()
{
    count=+1;
}
public static void sortByWord()
{
    compareByWord = true;
}
public static void sortByCount()
{
    compareByWord = false;
}
public String toString()
{
    String result = String.format("%s (%d)",word, count);
    return result;
}
}

我是怎么称呼的......

for (int i=0;i<tokens.length;i++)
        {
            if (tokens[i].length()>0)
            {
                WordCount word = new WordCount(tokens[i]);
                int foundAt = search(wordList, word, n);
                if (foundAt >= 0)
                {
                    wordList[foundAt].increment();
                }
                else
                {
                    wordList[n]=word;
                    n++;
                }
            }
        }
    }

Answer 1

默认情况下，Object#equals只返回两个引用是否引用同一个对象（与==运算符相同）。看看你在做什么，你需要做的是在WordCount中创建一个方法来返回word，例如：

public String getWord() {
    return word;
}

然后在search中更改您的比较：

if (word.equals(list[i]))

为：

if (word.getWord().equals(list[i].getWord()))

或者更改方法的签名以接受String，以便在不必要的情况下不创建新对象。

我建议不要在equals中覆盖WordCount，以便仅使用word来确定对象相等，因为您有其他字段。（例如，只有当两个计数器的计数相同时，人们才会期望两个计数器相等。）

另一种方法是使用Map这是一个关联容器。一个例子是这样的：

public static Map<String, WordCount> getCounts(String[] tokens) {
    Map<String, WordCount> map = new TreeMap<String, WordCount>();

    for(String t : tokens) {
        WordCount count = map.get(t);
        if(count == null) {
            count = new WordCount(t);
            map.put(t, count);
        }

        count.increment();
    }

    return map;
}

Answer 2

此方法可能无法正常工作，因为您使用的.equals（）的实现未正确检查两个对象是否相等。

您需要覆盖WordCount对象的equals（）和hashCode（）方法，或者让它返回您想要比较的内容，即：word.getWord().equals(list[i].getWord())

Answer 3

似乎更容易使用：

public static int search(WordCount[] list, WordCount word)
{
    for(int i = 0; i < list.length; i++){
        if(list[i] == word){
            return i;
        }
    }
    return -1;
}

这将检查数组中的每个值，并将其与您指定的单词进行比较。

Answer 4

当前方法中的奇怪之处在于您必须创建一个新的WordCount对象才能查找特定单词的计数。您可以添加类似

的方法

public boolean hasEqualWord(WordCount other)
{
    return word.equals(other.word);
}

在您的WordCount课程中，并使用它代替equals方法：

....
while (result < 0 && i < n)
{
    if (word.hasEqualWord(list[i])) // <--- Use it here!
    { 
    ....
    }
}

但我建议你重新考虑一下你要在那里建模的方式 - 以及如何。虽然它在技术上并不是错误的＆＃34;要创建一个总结单词及其计数的类，可能会有更多优雅的解决方案。例如，当这只是关于计算单词时，您可以考虑一个地图：

Map<String, Integer> counts = new LinkedHashMap<String, Integer>();
for (int i=0;i<tokens.length;i++)
{
    if (tokens[i].length()>0)
    {
        Integer count = counts.get(tokens[i]);
        if (count == null)
        {
            count = 0;
        }
        counts.put(tokens[i], count+1);
    }
}

之后，您可以在此地图中查找每个单词的出现次数：

String word = "SomeWord";
Integer count = counts.get(word); 
System.out.println(word+" occurred "+count+" times);

搜索对象数组

4 个答案: