计算文件中的相同行，JAVA

Question

我有一个包含动物行的文本文件，这些动物在此列表中出现 1 到 n 次。我需要阅读这个文本文件，计算所有单独的动物出现次数，将它们从高到低排序，然后将它们放入 jtable 中。

例如，文本文件如下所示：

dog
sheep
cat
horse
cat
tiger
cat
cat
tiger

我需要像这样计算所有相同的出现次数：

dog 1
sheep 1
cat 4
horse 1
tiger 2

然后将它们从高到低排序，并以某种方式将它们放入一个表中，这样就可以了：

Animal name: count
cat          4
tiger        2
dog          1
sheep        1
horse        1

所以，现在我的具体问题是如何计算所有单独动物的匹配数？

感谢您的帮助！

---

编辑

Vishal Kamat 提供的答案已经奏效，我的动物及其出现次数已用此代码计算：

java hashmap word count from a text file

现在，我只需要将所有这些信息放到一个新的 jtable 中

Answer 1

只需使用开关盒。您可以为每只动物使用一个计数器。或者使用 arrayList 来存储每只动物的数量...

   String line = reader.readLine();
        while (line != null) {
            switch (line) {
                case "cat":
                catCounter++;
                break;
                case "dog":
                dogCounter++;
                break;
                case "horse":
                horseCounter++;
                break;
                case "tiger":
                tigerCounter++;
                break;
                case "sheep":
                sheepCounter++;
                break;
                default:
                break;
            }
        }

Answer 2

很遗憾，我无法编写和测试代码，但我能够为您提供一条完成您想做的事情的途径。

您可以使用正则表达式匹配多少次，假设文本文件中提到了“猫”。

也许这会有所帮助：http://code.runnable.com/UqUJWzqM7L8-AAFT/how-to-count-the-number-of-matching-string-in-java-for-regex

代码不是我写的，感谢 Mirang。

Answer 3

您可以有一个Map<String, Integer>，其中 key 是动物名称，count 是迄今为止的出现次数。每次读取动物时，从地图中获取值并增加它。最后，您可以使用计数的整数值对 Map 进行排序并存储在表中。

Answer 4

你可以试试这个。如果你方便的话。

HashMap map=new HashMap();
HashSet set=new HashSet();
FileInputStream fis=new FileInputStream(file);
StreamTokenizer st=new StreamTokenizer(fis);
while(st.nextToken()!=StreamTokenizer.TT_EOF){

     Integer count=1;
     String s;
     switch(st.ttype)
     {
          case StreamTokenizer.TT_WORD:
          s=st.sval;
          if(map.containsKey(s))
          {
               count=(Integer)map.get(s);
               count++;
               map.put(s,count);
               set.add(s);
          }
          else
          {
               map.put(s,count);
               set.add(s);
          }
          break;
     }
}
//now you have a collection of words with their frequency.it will automatically sort numeric values
System.out.println("frequency of each word in file");
Iterator iter=set.iterator();//get all the keys from the HashSet

//display them with help of Iterator interface
while(iter.hasNext())
{
     String s=(String)iter.next();
     Integer count=(Integer)map.get(s);
     System.out.println("frequency of "+s+" : "+count);
}

Answer 5

这里的大多数答案要么太复杂，要么没有正确实施频率分布。以下是我的解决方案：

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

try (Scanner scanner = new Scanner(new File("path/to/file"), "UTF-8")) {
    while (scanner.hasNext()) {
        String temp = scanner.nextLine();
        if(frequency.containsKey(temp)) {
            Integer count = frequency.get(temp);
            frequency.put(temp, Integer.sum(count, 1));
        } else {
            frequency.put(temp, 1);
        }
    }
}

Map 的键包含动物名称和值（它是一个整数）包含到目前为止读取的动物名称的出现次数。每次迭代后，检查动物名称是否在键中。如果是，则增加其值。否则，放置一个值为 1 的新键值对。映射完成后，您可以随意使用它。

Answer 6

您可以使用 Java 8 Streams 做到这一点。该解决方案紧凑且极具表现力。它创建从文件中读取的行流。每个唯一的行成为一个组，它计算每个组中的条目，然后按组的值按降序对组进行排序。

既然你想把这些放在一个 JTable 中，你需要一个二维数组。

package com.test;

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.swing.JTable;

public class TestCount {

    public static void main(String args[]) throws URISyntaxException, IOException {
        // for absolute path use: Paths.get("/path/to/animals.txt")
        try (Stream<String> stream = Files.lines(Paths.get(TestCount.class.getClassLoader().getResource("animals").toURI()))) {

            Object[][] data = stream
                    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())).entrySet().stream()
                    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                    .map((entry) -> new Object[] { entry.getKey(), entry.getValue() })
                    .toArray(Object[][]::new);

            // print the data
            for (Object[] row : data) {
                System.out.println(Arrays.toString(row));
            }

            // create the JTable
            new JTable(data, new String[] { "animal", "count" });
        }
    }
}

如果你已经有一个排序的 Map，你可以像这样转换成一个二维数组：

Object[][] data = m1.entrySet().stream()
        .map((entry) -> new Object[] { entry.getKey(), entry.getValue() })
        .toArray(Object[][]::new);