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

不幸的是，我无法编写和测试代码，但我能够为您提供完成所需操作的途径。

您可以使用Regex进行匹配多少次，让我们说＆＃34; cat＆＃34;在文本文件中提到。

也许这会有所帮助：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是动物名称，计数到目前为止都是出现的。每当您阅读动物时，从地图中获取值并递增它。最后，您可以使用计数的整数值对表进行排序并存储在表中。

Answer 4

您可以使用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" });
        }
    }
}

如果您已经有一个有序的地图，您可以转换为二维数组，如下所示：

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

Answer 5

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

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 6

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

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.一旦填充了Map，就可以随意使用它。

计算文件中的相同行，JAVA

修改

6 个答案: