Question

我有一个方法，它从另一个向量中获取矢量形式的参数。此向量可以是2,3或4个元素。

我想计算该向量中每个单词的频率。例如，如果向量包含字符串：“hello”，“my”，“hello”，我想输出一个数组 [2,1]其中2是你好的频率，1是我的频率。

这是我在阅读本网站上的几个问题后的尝试：

    int vector_length = query.size();
    int [] tf_q = new int [vector_length];
    int string_seen = 0;

    for (int p = 0; p< query.size(); p++)
    {
        String temp_var = query.get(p);

        for (int q = 0; q< query.size(); q++)
        {
            if (temp_var == query.get(q) )
            {
                if (string_seen == 0)
                {
                    tf_q[p]++;
                    string_seen++;
                }

                else if (string_seen == 1)
                {
                    tf_q[p]++;
                    string_seen = 0;
                    query.remove(p);
                }
            }
        }
    }

    System.out.print(Arrays.toString(tf_q));

什么是正确的方向？

Answer 1

使用类型的HashMap来跟踪您遇到的计算每个单词的唯一字符串值

String[] vector // your vector
Map<String, Integer> stringMap = new HashMap<String, Integer>();

for (int i = 0; i < vector.length; i++) {
  if (stringMap.containsKey(vector[i]) {
    Integer wordCount = stringMap.get(vector[i]);
    stringMap.put(vector[i], new Integer(wordCount + 1));
  }
  else {
    stringMap.put(vector[i], new Integer(1));
  }
}

Answer 2

    String[] input = {"Hello", "my", "Hello", "apple", "Hello"};
    // use hashmap to track the number of strings
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    // use arraylist to track the sequence of the output
    ArrayList<String> list = new ArrayList<String>(); 
    for (String str : input){
        if(map.containsKey(str)){
            map.put(str, map.get(str)+1);
        } else{
            map.put(str, 1);
            list.add(str); // if the string never occurred before, add it to arraylist
        }
    }


    int[] output = new int[map.size()];
    int index = 0;
    for (String str : list){
        output[index] = map.get(str);
        index++;
    }

    for (int i : output){
        System.out.println(i);
    }

这应该是你的答案！结果在“int [] output”

中

Answer 3

如果您想保持每个单词与该单词的频率之间的关系，那么我建议您使用HashMap代替。例如：

Map<String,Integer> histogram = new HashMap<String,Integer>();
for (String word : query)
{
    Integer count = histogram.get(word);
    if (count == null)
        histogram.put(word,1);
    else
        histogram.put(word,count+1);
}

此时，您可以（例如）以相应的频率打印每个单词：

for (String word : histogram.keySet())
    System.out.println(word+" "+histogram.get(word));

或者你可以获得一个只包含频率的数组，如果你想要的话：

Integer[] array = histogram.values().toArray(new Integer[histogram.size()]);

甚至是一个集合，它与任何本机数组一样有用和方便：

Collection<Integer> collection = histogram.values();

计算向量中唯一值的数量

3 个答案: