如何计算字符串中相同的单词并获得第一个相等的单词的索引？

Question

我的任务是创建一个名为“dupWords”的静态方法，它获取一个字符串作为参数并返回一个单词在同一个字符串中出现的次数。现在要注意的是，我需要将它作为二维数组返回，它有 2 列，行将是字符串中有多少不同的子字符串...

例如：“abcd xyz abcd abcd def xyz”

这将是对 [0][3] [5][2] [19][01] 第一对意味着单词“abcd”出现了 3 次并在索引 0 处声明（你得到休息..)

这是二维数组的图像：（文字是希伯来语，但你可以看到图纸）

我开始了一些事情......你可能会认为它的方式：/（它只是一些开始） 我想我并没有真正理解如何处理二维数组..

public static int[][] dupWords (String str) {

        String [] stringArray = str.split(" ");
        int countWords = 0;
        int index = 0;
        int [][] retArr;

        for (int i = 0; i < stringArray.length; i++) {
            for (int j = 0; j < stringArray.length; j++) {
                if (stringArray[i].equalsIgnoreCase(stringArray[j])){
                    countWords++;
                    index = stringArray[i].indexOf(str); 
                }
            }
        }
    }

请帮忙， 谢谢

Answer 1

找出唯一词的数量。

您可以通过将stringArray 中的所有单词放入哈希图来做到这一点。 hashmap 稍后会派上用场。

创建一个这样的数组 retArr = new int[unique][2];

下面的完整解决方案（注意，我什至没有编译它！）

public static int[][] dupWords (String str) {

    String [] stringArray = str.split(" ");
    int countWords = 0;
    int index = 0;
    HashMap<String, Integer> indexMap = new HashMap<String, Integer>();
    HashMap<String, Integer> countMap = new HashMap<String, Integer>();

    int index = 0;
    for (int i = 0; i < stringArray.size(); i++) {
       String s = stringArray[i];
       if (!indexMap .containsKey(s)) {
         indexMap.put(s, index);
         countMap.put(s, 1);
       }
       else {
         int cnt = countMap.get(s);
         countMap.put(s, cnt+1);
       }
       index += s.length() + 1;
    }

    int [][] retArr = new int[map.size()][2];

    for (int i = 0; i < stringArray.size(); i++) {
       String s = stringArray[i];
       retArr[i][0] = indexMap.get(s);
       retArr[i][1] = countMap.get(s);
    }

    return retArr;
}

现在，如果没有 HashMap 或任何其他动态结构，这很难做到。最简单的方法是创建一个比必要更大的数组并在最后修剪它。这可能看起来像这样。

public static int[][] dupWords (String str) {

    String [] stringArray = str.split(" ");
    int countWords = 0;
    int index = 0;

    int [][] retArr = new int[stringArray.size()][2];

    int uniqeWords = 0;
    for (int i = 0; i < stringArray.size(); i++) {
       String s = stringArray[i];
       if (s != null) {
         retArr[uniqueWords][0] = str.indexOf(s);
         int cnt = 1;
         for (int j = i + 1; j < stringArray.size(); j++) {
           if (s.equalsIgnoreCase(stringArray[j])) {
             stringArray[j] = null;
             cnt++;
           }
         }
         retArr[uniqueWords][1] = cnt;
         uniqueWords++;
       }
    }

    int[][] newRetArr = new int[uniqueWords][2];
    for (int i = 0; i < uniqueWords; i++) {
      newRetArr[i][0] = retArr[i][0];
      newRetArr[i][1] = retArr[i][1];
    }

    return newRetArr;
}

Answer 2

使用HashMap 存储每个唯一单词的计数和第一个索引。

Map<String, Map<String, int>> uniqueWords = new HashMap<>();

然后通过stringArray 更改您的循环以仅使用第一个外部循环。您不需要内部循环。

在通过stringArray的每次迭代中，做

if(!uniqueWords.get(stringArray[i])) {
    uniqueWords.put(stringArray[i], new HashMap<String, int>());
    uniqueWords.get(stringArray[i]).put("Count", 0);
    uniqueWords.get(stringArray[i]).put("Index", str.indexOf(stringArray[i]));
}

uniqueWords.get(stringArray[i]).get("Count")++;

然后您可以使用 uniqueWords 映射来构建您的返回数组。我会把它留给你编码。