单词统计续

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量57 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/NCLONG/p/11062486.html
版权 
package test;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
 
  
public class W1 {
    static Scanner in = new Scanner(System.in);
 
    public static void main(String[] args) throws IOException {
         
        deal();
        }
         
         
         
 
     
public static void deal() throws IOException
{
    int choice = 0;
     
    while(choice != 5)
    {
        System.out.println("请输入选择");
        System.out.println("0输出字母");
        System.out.println("1输出单词");
        System.out.println("2输出前n个单词");
        System.out.println("3过滤无用词");
        System.out.println("4统计短语");
         
         
        choice = in.nextInt();
        switch (choice)
        {
        case 0 :
        {
            word();
            break;
        }
        case 1:
        {
            String filePath = "d:\\文件\\单词.txt";
            String sz=W3.readTxtFile(filePath);
            System.out.println(W2.StatList1(sz)); 
            break;
        }
        case 2:
        {
            String filePath = "d:\\文件\\单词.txt";
            String sz=W3.readTxtFile(filePath);
            System.out.println(W2.StatList2(sz)); 
            break;
        }
        case 3:
        {
            String filePath = "d:\\文件\\单词.txt";
            String sz=W3.readTxtFile(filePath);
            System.out.println(W2.StatList(sz)); 
            break;
        }
         
        case 4:
        {
            String filePath = "d:\\文件\\stopword.txt";
            String sz=W3.readTxtFile(filePath);
            String[] slist = sz.split("[^a-zA-Z\']+");
             
            break;
        }
        }
        }
}
     
     
     
     
 
 
public static void word() throws IOException
{
    try {
        //IO操作读取文件内容
        FileReader fr = new FileReader("d:\\文件\\单词.txt");
        BufferedReader br = new BufferedReader(fr);
        NumberFormat nf = NumberFormat.getInstance();
          
        // 设置精确到小数点后2位
  
        nf.setMaximumFractionDigits(2);
        HashMap<String, Integer> map = new HashMap<String, Integer>();
         
        String string =null;
        Integer count = 0;//每个字母的次数
        Integer total = 0;//总共多少个字母
         
        while ((string=br.readLine())!=null) {
            char[] ch = string.toCharArray();
             
            for (int i = 0; i < ch.length; i++) {
                if (ch[i] > 'A' && ch[i]< 'z') {
                     
                total++;
                ch[i] = Character.toLowerCase(ch[i]);
                count = map.get(ch[i]+"");
                if (count == null) {
                    count = 1;
                }else {
                    count++;
                }
                map.put(ch[i]+"", count);
            }
            }
        }
         ArrayList<String> list = new ArrayList<String>();
         list.addAll(map.keySet());  //将单词添加到list中
          
         //排序按照出现次数降序排列
         for(int i = 0;i < list.size();i++)
         {
              
             for(int j = 0;j < (list.size() - i-1);j++)     //list.size() - i-1因为要用到i+1要考虑是否超出范围的问题
             {
                  
                 if(map.get(list.get(j)) < map.get(list.get(j+1)))
                 {
                     String t = list.get(j);
                     list.set(j, list.get(j+1));
                     list.set( j+1, t);
                 }
             }
         }
         for(int i = 0 ; i < list.size();i++)
            {
                System.out.println(list.get(i) + ":" + map.get(list.get(i)) +"   "+ nf.format((float)(map.get(list.get(i)))*100/total) + "%");
            }
         
         
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
 
 
 
}


package test;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
 
 
public class W2 {
 
 
public static String StatList2(String str) {
    StringBuffer sb = new StringBuffer();
    HashMap<String ,Integer> has = new HashMap<String ,Integer> (); // 打开一个哈希表
    String[] slist = str.split("[^a-zA-Z\']+");
    for (int i = 0; i < slist.length; i++) 
    {
        if (!has.containsKey(slist[i])) 
        { 
               has.put(slist[i], 1);
        } 
        else
        {
               has.put(slist[i],has.get(slist[i])+1 );
        }
    }
    Iterator<String> iterator = has.keySet().iterator();
    String a[]=new String[100];
    int s[]=new int[100];
    int n;
    Scanner in=new Scanner(System.in);
    System.out.println("输入前n个最常出现的单词:");
    n=in.nextInt();
    for(int i=0;i<n;i++)
    {
        iterator = has.keySet().iterator();
        while(iterator.hasNext())
        {
            String word = (String) iterator.next();
            if(s[i]<has.get(word))
            {
                s[i]=has.get(word);
                a[i]=word;
            }
         }
         
         sb.append("单词：").append(a[i]).append(" 次数").append(has.get(a[i])).append("\r\n");
         has.remove(a[i]);
         
    }
         return sb.toString();
    }
 
public static String StatList1(String str) {
    StringBuffer sb = new StringBuffer();
    HashMap<String ,Integer> has = new HashMap<String ,Integer> (); // 打开一个哈希表
    String[] slist = str.split("[^a-zA-Z\']+");
    for (int i = 0; i < slist.length; i++) 
    {
        if (!has.containsKey(slist[i])) 
        { 
               has.put(slist[i], 1);
        } 
        else
        {
               has.put(slist[i],has.get(slist[i])+1 );
        }
    }
    Iterator<String> iterator = has.keySet().iterator();
    String a[]=new String[100];
    int s[]=new int[100];
     
     
    for(int i=0;i<50;i++)
    {
        iterator = has.keySet().iterator();
        while(iterator.hasNext())
        {
            String word = (String) iterator.next();
            if(s[i]<has.get(word))
            {
                s[i]=has.get(word);
                a[i]=word;
            }
         }
         
        
         sb.append("单词：").append(a[i]).append(" 次数").append(has.get(a[i])).append("\r\n");
         has.remove(a[i]);
         
    }
         return sb.toString();
    }
 
public static String StatList(String str) {
    StringBuffer sb = new StringBuffer();
    HashMap<String ,Integer> has = new HashMap<String ,Integer> (); // 打开一个哈希表
    String[] slist = str.split("[^a-zA-Z\']+");
    for (int i = 0; i < slist.length; i++) 
    {
        if (!has.containsKey(slist[i])) 
        { 
               has.put(slist[i], 1);
        } 
        else
        {
               has.put(slist[i],has.get(slist[i])+1 );
        }
    }
    Iterator<String> iterator = has.keySet().iterator();
    String a[]=new String[100];
    int s[]=new int[100];
    int n=15;
    int judge;
    Scanner in=new Scanner(System.in);
    System.out.println("输入前n个最常出现的单词:");
    n=in.nextInt();
    for(int i=0;i<n;i++)
    {
        iterator = has.keySet().iterator();
        while(iterator.hasNext())
        {
            String word = (String) iterator.next();
            if(s[i]<has.get(word))
            {
                s[i]=has.get(word);
                a[i]=word;
            }
         }
        judge=woor(a[i]);
        if(judge==1)
        {
            n++;
            has.remove(a[i]);
        }
        else
        {
         sb.append("单词：").append(a[i]).append(" 次数").append(has.get(a[i])).append("\r\n");
         has.remove(a[i]);
        }
    }
         return sb.toString();
    }
    public static void main(String[] args) 
    {
        File file = new File("d:\\文件");
//      // TODO Auto-generated method stub
//      ArrayList<String> fil=getFiles("d:\\文件");//目录下的文件
        ArrayList<String> fil=getDirectory(file);//目录下的文件和子目录里的文件
        for(int i=0;i<fil.size();i++)
        {
        String filePath = fil.get(i);
        //String filePath = "d:\\文件\\单词.txt";
        String sz=W3.readTxtFile(filePath);
        String ltxt=null;
        System.out.println(ltxt=StatList(sz)); 
        try {
        W3.daochu(ltxt);
        } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        }
        }
         
    }
     
    public static int woor(String a)
    {
        int n=0;
        String filePath = "d:\\文件\\stopword.txt";
        String sz=W3.readTxtFile(filePath);
        String[] slist = sz.split("[^a-zA-Z\']+");
        for(int i=0;i<slist.length;i++)
        {
            if(slist[i].equals(a))
            {
                n=1;
            }
        }
        return n;
    }
     
    public static ArrayList<String> getFiles(String path) {
        ArrayList<String> files = new ArrayList<String>();
        File file = new File(path);
        File[] tempList = file.listFiles();
        for (int i = 0; i < tempList.length; i++) {
            if (tempList[i].isFile()) {
                files.add(tempList[i].toString());
            }
            if (tempList[i].isDirectory()) {
            }
        }
        return files;
    }
     
    private static ArrayList<String> getDirectory(File file) {
        ArrayList<String> files = new ArrayList<String>();
        ArrayList<String> files1 = new ArrayList<String>();
        //获取该目录下的文件列表
        File flist[] = file.listFiles();
        for (File f : flist) {
            if (f.isDirectory()) {
                // 如果f是一个目录
                files1=getFiles(f.getAbsolutePath());
                files.addAll(files1);
                
                getDirectory(f);
            } else {
                //如果f是一个文件
                files.add(f.getAbsolutePath());
            }
        }
        return files;
    }
 
 
}


package test;
 
import java.io.BufferedReader; 
import java.io.File; 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter; 
//import java.io.Reader; 
//从文本文档中读入
public class W3 {
    public static String readTxtFile(String filePath){ 
        try { 
            String encoding="GBK"; 
            File file=new File(filePath); 
            if(file.isFile() && file.exists()){ //判断文件是否存在 
            InputStreamReader read = new InputStreamReader( 
            new FileInputStream(file),encoding);//考虑到编码格式 
            BufferedReader bufferedReader = new BufferedReader(read); 
            String lineTxt = null;
            String lineText="";
            while((lineTxt = bufferedReader.readLine()) != null)
                { 
                lineText+=(lineTxt); 
                } 
            read.close(); 
            return lineText;
            }
            else
                { 
                System.out.println("找不到指定的文件"); 
                } 
            } catch (Exception e) { 
            System.out.println("读取文件内容出错"); 
            e.printStackTrace(); 
            } 
            return null;
        } 
        public static void daochu(String a) throws IOException
        {
            File file=new File("d:\\文件\\c.txt");
            FileOutputStream fos=new FileOutputStream(file);
            OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
            osw.append(a);
            osw.close();
            fos.close();
        }
}

　　

转载于:https://www.cnblogs.com/NCLONG/p/11062486.html

weixin_30598225
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python学习笔记第五天续
12-22
本篇笔记主要讨论了字符串的一些基本操作，包括切割、拼接、查找、统计、更改和替换，以及相关的判断方法。此外，还涉及了字符串的对齐与填充、去除特定内容的功能。最后，笔记介绍了Python中的深浅拷贝概念，特别是...
雅思听写王
11-10
2. **断点续听**：用户可以设置特定的时间间隔暂停，然后手动输入听到的内容，这样可以模拟考试中的听写环节。 3. **自动回放**：如果用户在某个部分没有听清楚或者没来得及写下，软件可以自动回放该部分，以确保每...
T001-UT001-0018
Confidence_Surmount的专栏
04-12 562
集合练习 编写一个程序，从标准输入设备上输入若干行英文语句，直到输入的一行字符串等于"finished input"。回车后停止输入，并对所输入的所有语句进行分析，统计除逗号,句号，感叹号和问号以外的所有单词的频次并打印在标准输出设备上。输出顺序按Java语言的字符串的自然顺序排序。 字符串自然顺序是指，对字符串从左到右，每个字符按照其字符的ascii码从小到大排序，如果第1个字符
单词 统计 续
weixin_30924087的博客
05-12 170
题目要求： 第1步：输出单个文件中的前 N 个最常出现的英语单词。 功能1：输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列。 功能2：指定文件目录，对目录下每一个文件执行统计的操作。 功能3：指定文件目录，是会递归遍历目录下的所有子目录的文件进行统计单词的功能。 功能4：输出出现次数最多的前 n 个单词， 例如，提示统计统计前多少名：输入...
单词 统计续
weixin_30498921的博客
05-11 108
第1步：输出单个文件中的前 N 个最常出现的英语单词。 功能1：输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列。 功能2：指定文件目录，对目录下每一个文件执行统计的操作。 功能3：指定文件目录，是会递归遍历目录下的所有子目录的文件进行统计单词的功能。 功能4：输出出现次数最多的前 n 个单词， package test; import...
单词统计 续
weixin_30336061的博客
05-12 122
package wordcount; //20173600 王重阳 import java.io.BufferedReader; import java.io.File; import java.io.FileOutputStream; import java.io.FileReader; import java.io.IOException; import java....
100.rar_下落 打字 游戏_打字_键盘打字练习
07-14
键盘打字练习游戏。本程序实现键盘打字练习功能，用户可续选择练习的难易程度，根据难易程度的不同，字母下落的速度会有所区别，游戏结束之后，程序能够统计用户练习的结果并输出。
Natural Language Processing Language Modelling and Machine Translation
04-10
例如给定的语境是"Shebuilta"时，一个良好的模型应能够利用更多的上下文信息来极大地限制下一个单词的概率分布，例如在"Alicewenttothebeach.There"后面，模型应该能够预测出"Shebuilta"是更合理的续句。 在评估...
南开三级C语言上机南开100题
06-16
8. **字符串处理（续）**：题目4的`StrOL`函数涉及到字符串的单词倒序操作。这需要理解如何根据空格和标点符号分割单词，然后反向存储这些单词。可能需要使用`strtok`或`sscanf`函数来分割字符串，以及`strncpy`或`...
JAVA进阶补充
2301_80150315的博客
08-15 565
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 520
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 883
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 256
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
旅游网站
weixin_43213064的博客
08-16 597
【代码】springboot旅游网站
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 942
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 706
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 270
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 974
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
单词统计 单词原型化
04-03
单词统计是指对文本中出现的单词进行数量统计的过程。这个过程可以帮助人们更好地了解文本的内容和特点，也可以为后续的文本处理工作提供基础数据。 在进行单词统计的过程中，需要注意一些细节问题。例如，需要把...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值