java实现文件单词频率统计

简介:

思路:  

1、将文件内容存入StringBuffer中。

  2、利用split()函数分割字符串,可按(“,”,“.”,“!”,“空格”,“回车”)分割,得到一个数组。  

3、遍历数组,将其放入一个Map <String,Integer>中,key=单词,value=单词出现的次数。  

4、如要求出文件中出现频率最高的几个单词,则要对Map进行排序。  

-----------------------------------------------------------------------------------------------------------------------------------------

  以下是实现一个文件中出现频率最高的单词的统计   FileWordCount.java主函数所在文件

import  java.io.BufferedReader;
  import  java.io.FileNotFoundException;
  import  java.io.FileReader;
  import  java.io.IOException;
  import  java.util.*;
  
/**
   * Created by IntelliJ IDEA.
   * User: FLY
   * Date: 11-9-13
   * Time: 下午3:59
   * To change this template use File | Settings | File Templates.
   */
  public  class  FileWordCount {
      public  static  void  main(String[] args) {
          try  {
              BufferedReader br = new  BufferedReader( new  FileReader( "D:\\test.txt" ));
              String s;
              StringBuffer sb = new  StringBuffer();
              while  ((s = br.readLine()) != null ) {
                  sb.append(s);
              }
              Map<String,Integer> map = new  HashMap<String, Integer>();
              StringTokenizer st = new  StringTokenizer(sb.toString(), ",.! \n" );
              while  (st.hasMoreTokens()) {
                  String letter = st.nextToken();
                  int  count;
                  if  (map.get(letter) == null ) {
                      count = 1 ;
                  } else  {
                      count = map.get(letter).intValue() + 1 ;
                  }
                  map.put(letter,count);
              }
              Set<WordEntity> set = new  TreeSet<WordEntity>();
              for  (String key : map.keySet()) {
                  set.add( new  WordEntity(key,map.get(key)));
              }
              // 自己拼接字符串,输出我们想要的字符串格式
              System.out.println( "输出形式一:" );
              for  (Iterator<WordEntity> it = set.iterator(); it.hasNext(); ) {
                  WordEntity w = it.next();
                  System.out.println( "单词:"  + w.getKey() + " 出现的次数为: "  + w.getCount());
              }
              // 直接打印 WordEntity 对象,实现我们想要的输出效果,只需在WordEntity类中重写toString()方法
              System.out.println( "输出形式二:" );
              for  (Iterator<WordEntity> it = set.iterator(); it.hasNext(); ) {
                  WordEntity w = it.next();
                  System.out.println(w);
              }
              // 我们可以控制只输出前三名来
              System.out.println( "输出形式三:" );
              int  count = 1 ;
              for  (Iterator<WordEntity> it = set.iterator(); it.hasNext(); ) {
                  WordEntity w = it.next();
                  System.out.println( "第"  + count + "名为单词:"  + w.getKey() + " 出现的次数为: "
                          + w.getCount());
                  if  (count == 3 ) // 当输出3个后跳出循环
                      break ;
                  count++;
              }
          } catch  (FileNotFoundException e) {
              System.out.println( "文件未找到~!" );
          } catch  (IOException e) {
              System.out.println( "文件读异常~!" );
          }
      }
  }
  
  
  
WordEntity.java文件
  
/**
   * Created by IntelliJ IDEA.
   * User: FLY
   * Date: 11-9-13
   * Time: 下午4:57
   * To change this template use File | Settings | File Templates.
   */
  public  class  WordEntity implements  Comparable<WordEntity> {
      private  String key;
      private  Integer count;
      public  WordEntity (String key, Integer count) {
          this .key = key;
          this .count = count;
      }
      public  int  compareTo(WordEntity o) {
          int  cmp = count.intValue() - o.count.intValue();
          return  (cmp == 0  ? key.compareTo(o.key) : -cmp);
          //只需在这儿加一个负号就可以决定是升序还是降序排列  -cmp降序排列,cmp升序排列
          //因为TreeSet会调用WorkForMap的compareTo方法来决定自己的排序
      }
  
     @Override
      public  String toString() {
          return  key + " 出现的次数为:"  + count;
      }
  
     public  String getKey() {
          return  key;
      }
  
     public  Integer getCount() {
          return  count;
      }
  }
  
 
  
  
输出结果:
  
输出形式一:
  单词:is 出现的次数为: 4
  单词:my 出现的次数为: 2
  单词:very 出现的次数为: 2
  单词:word 出现的次数为: 2
  单词:a 出现的次数为: 1
  单词:are 出现的次数为: 1
  单词:boy 出现的次数为: 1
  单词:english 出现的次数为: 1
  单词:fool 出现的次数为: 1
  单词:good 出现的次数为: 1
  单词:hah 出现的次数为: 1
  单词:hello 出现的次数为: 1
  单词:hey 出现的次数为: 1
  单词:i 出现的次数为: 1
  单词:love 出现的次数为: 1
  单词:mary 出现的次数为: 1
  单词:much 出现的次数为: 1
  单词:name 出现的次数为: 1
  单词:ok 出现的次数为: 1
  单词:poor 出现的次数为: 1
  单词:so 出现的次数为: 1
  单词:sophie 出现的次数为: 1
  单词:you 出现的次数为: 1
  输出形式二:
  is 出现的次数为: 4
  my 出现的次数为: 2
  very 出现的次数为: 2
  word 出现的次数为: 2
  a 出现的次数为: 1
  are 出现的次数为: 1
  boy 出现的次数为: 1
  english 出现的次数为: 1
  fool 出现的次数为: 1
  good 出现的次数为: 1
  hah 出现的次数为: 1
  hello 出现的次数为: 1
  hey 出现的次数为: 1
  i 出现的次数为: 1
  love 出现的次数为: 1
  mary 出现的次数为: 1
  much 出现的次数为: 1
  name 出现的次数为: 1
  ok 出现的次数为: 1
  poor 出现的次数为: 1
  so 出现的次数为: 1
  sophie 出现的次数为: 1
  you 出现的次数为: 1
  输出形式三:
  1 名为单词:is 出现的次数为: 4
  2 名为单词:my 出现的次数为: 2
  3 名为单词:very 出现的次数为: 2

  原文地址

方法二

//CountWord.java
  
package  com.xie.tencent;
  
import  java.io.BufferedReader;
  import  java.io.FileInputStream;
  import  java.io.FileNotFoundException;
  import  java.io.IOException;
  import  java.io.InputStreamReader;
  import  java.util.HashMap;
  
/**
   * 这个类用于统计某个单词在所有文件中出现的次数。
   * @author centre
   *
   */
  public  class  CounterWord {
      FileReader fr;
      private  HashMap<String, Integer> hMap= new  HashMap<String, Integer>();;
      
   public  HashMap<String, Integer> gethMap() {
    return  hMap;
   }
   /**
    * 这个构造方法用于持有对方引用
    * @author centre
    * @param f FileReader
    */
   public  CounterWord(FileReader f) {
    fr=f;
   }
   /**
    * 根据传入的文件路径,打开文件,同时分析其中的单词个数,
    * 存放进一个HashMap
    * @author centre
    * @param path String 文件的绝对路径
    * @return 返回值貌似没用,在需要时可以接收
    */
   public  boolean  openFile(String path){
    boolean  b= true ;
    try  {
         FileInputStream fis= new  FileInputStream(path);
         BufferedReader br= new  BufferedReader( new  InputStreamReader(fis));
         try  {
           String words=br.readLine();
           while  (words!= null ) {
            //System.out.println(words);
            String[] word=words.split( "," );
            for  ( int  i = 0 ; i < word.length; i++) {
           addWordCount(word[i]);
       }
            words=br.readLine();
      }
     } catch  (IOException e) {
      System.out.println( "文件读取异常。" );
      e.printStackTrace();
     }
         
    } catch  (FileNotFoundException e) {
     System.out.println( "没有找到该文件:" +path);
     b= false ;
     e.printStackTrace();
    }
    return  b;
   }
   /**
    * 将单词放进map,同时统计单词出现的次数
    * @param word String 单词
    */
   private  void  addWordCount(String word) {
    if  (hMap.containsKey(word)) {
     hMap.put(word, hMap.get(word).intValue()+ 1 );
    } else  {
     hMap.put(word, 1 );
    }
   }

  


本文转自Work Hard Work Smart博客园博客,原文链接:http://www.cnblogs.com/linlf03/archive/2013/01/17/2865251.html,如需转载请自行联系原作者

目录
相关文章
|
1月前
|
Java
java小工具util系列5:java文件相关操作工具,包括读取服务器路径下文件,删除文件及子文件,删除文件夹等方法
java小工具util系列5:java文件相关操作工具,包括读取服务器路径下文件,删除文件及子文件,删除文件夹等方法
77 9
|
1月前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
83 2
|
21天前
|
Java
java实现从HDFS上下载文件及文件夹的功能,以流形式输出,便于用户自定义保存任何路径下
java实现从HDFS上下载文件及文件夹的功能,以流形式输出,便于用户自定义保存任何路径下
82 34
|
1月前
|
消息中间件 存储 Java
RocketMQ文件刷盘机制深度解析与Java模拟实现
【11月更文挑战第22天】在现代分布式系统中,消息队列(Message Queue, MQ)作为一种重要的中间件,扮演着连接不同服务、实现异步通信和消息解耦的关键角色。Apache RocketMQ作为一款高性能的分布式消息中间件,广泛应用于实时数据流处理、日志流处理等场景。为了保证消息的可靠性,RocketMQ引入了一种称为“刷盘”的机制,将消息从内存写入到磁盘中,确保消息持久化。本文将从底层原理、业务场景、概念、功能点等方面深入解析RocketMQ的文件刷盘机制,并使用Java模拟实现类似的功能。
43 3
|
1月前
|
Java 测试技术 Maven
Maven clean 提示文件 java.io.IOException
在使用Maven进行项目打包时,遇到了`Failed to delete`错误,尝试手动删除目标文件也失败,提示`java.io.IOException`。经过分析,发现问题是由于`sys-info.log`文件被其他进程占用。解决方法是关闭IDEA和相关Java进程,清理隐藏的Java进程后重新尝试Maven clean操作。最终问题得以解决。总结:遇到此类问题时,可以通过任务管理器清理相关进程或重启电脑来解决。
|
5天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
7天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
7天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
|
7天前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式:助您写出线程安全的代码
`synchronized` 是 Java 中的关键字,用于实现线程同步,确保多个线程互斥访问共享资源。它通过内置的监视器锁机制,防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块,分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器,JDK 1.6 后引入了偏向锁、轻量级锁等优化措施,提高了性能。
24 3
|
7天前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
77 2