精华内容
下载资源
问答
  • 文本单词统计
    千次阅读
    2020-12-21 21:22:50

    在以前的文章中,我提到过Python标准库中的collections模块中的Counter类。它的作用非常大,这里我们要用利它来实现单词统计。对于任意一篇全英文的文本文件,我们要列出其中每一个单词各自出现的次数。

    我们可以用正则表达式来提取文件中的英文单词(正则表达式是一个极其强大的工具),接着将他们装入列表中,最后用Counter类来统计单词出现频次。

    from collections import Counter

    import re

    """

    计算一篇英文文章中的单词个数

    """

    #为了方便设置默认文件名

    def word_count(filename='test.txt'):

    with open(filename, 'r') as f:

    data = f.read()

    #将大小写统一

    data = data.lower()

    #去除特殊字符和数字

    datalist = re.split(r'[sn]+', data)

    return Counter(datalist).most_common()

    if __name__ == '__main__':

    wc = word_count()

    for i in range(len(wc)):

    print ('%15s  ---->  %3s' %(wc[i][0], wc[i][1]))

    为了避免可能出现的大小写不同的问题使得含大写的单词和小写单词被区别对待,我们使用lower来将所有单词统一为小写

    re.split():

    re.split

    可以使用re.split来分割字符串,如:re.split(r’s+’, text);将字符串按空格分割成一个单词列表。

    原型:

    re.split(pattern, string, maxsplit=0)

    通过正则表达式将字符串分离。如果用括号将正则表达式括起来,那么匹配的字符串也会被列入到list中返回。maxsplit是分离的次数,maxsplit=1分离一次,默认为0,不限制次数。

    这样我们创建了一个只有单词的列表

    最后我们用Counter()来统计,他是一个容器类型,将数据以字典键值对形式存储,其中key为列表中的元素,而value为该元素出现的字数。

    most_common():返回一个TopN列表。如果n没有被指定,则返回所有元素。当多个元素计数值相同时,排列是无确定顺序的。这样我们就返回了一个list类型数据。方便我们最后格式化输出。

    最后几行代码就比较简单了,不过是做一个输出处理。

    贴一下部分输出:

    这是我随便找的一篇英文小说的一部分,看来the确实是一个高频词汇啊。

    the  ---->   20

    and  ---->   15

    to  ---->   15

    of  ---->   14

    a  ---->   11

    it  ---->   10

    was  ---->   10

    he  ---->    8

    in  ---->    7

    all  ---->    7

    that  ---->    6

    his  ---->    6

    hadleyburg  ---->    5

    their  ---->    5

    for  ---->    5

    so  ---->    4

    were  ---->    4

    at  ---->    4

    更多相关内容
  • 文本单词统计(C语言)

    千次阅读 2022-04-16 19:53:40
    统计文本文件中单词的个数(不区分大小写)

    要求:任给一个英文文本文件,统计该文本的所有单词(不区分大小写),包括其出现的总次数,频度,以及出现的行号和位置

    1.进行数据结构的准备(链表)

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    typedef struct Coordinate {
    	int line;                       //行号
    	int row;                        //列号
    	struct Coordinate* next;
    } Coord;
    
    typedef struct NUM {
    	char Num[100];					//单词
    	float i;						//次数
    	Coord *P;
    	struct NUM* next;
    } number;
    
    void Sum();
    
    int main() {
    	Sum();				//统计单词总数
    	return 0;
    }
    

    2.Sum函数的具体描述

    void Sum() {
    	int i,j,row_1=1,line_1=1;
    	float sum=0;
    	char ch;
    	number *N,*head,*end;
    	head=(number*)malloc(sizeof(number));
    	end=head;
    	FILE*file;
    	if((file=fopen("sum.txt","r"))==NULL) {          //选择相应的文本文件
    		printf("不能打开文件");
    		exit(0);
    	}
    	N=(number*)malloc(sizeof(number));
    	while(fscanf(file,"%s",N->Num)!=EOF) {
    		N->P=(Coord*)malloc(sizeof(Coord));
    		N->i=1;
    		end->next=N;
    		end=N;
    		sum++;
    		fscanf(file,"%c",&ch);
    		if(ch!='\n') {
    			N->P->row=row_1;
    			N->P->line=line_1;
    			row_1++;
    		} else {
    			N->P->row=row_1;
    			N->P->line=line_1;
    			row_1=1;
    			line_1++;
    		}
    		N=(number*)malloc(sizeof(number));
    	}
    	end->next=NULL;
    	fclose(file);
    	printf("这篇文章共有%.0f个单词\n",sum);
    	number *A,*B;
    	Coord* HEAD,*M,*END;
    	A=head->next;
    	B=A->next;
    	while(A->next!=NULL) {
    		HEAD=(Coord*)malloc(sizeof(Coord));
    		HEAD=A->P;
    		END=HEAD;
    		while(B->next!=NULL) {
    			if(strcasecmp(A->Num,B->Num)==0) {
    				M=(Coord*)malloc(sizeof(Coord));
    				A->i=A->i+B->i;
    				B->i=0;
    				M=B->P;
    				END->next=M;
    				END=M;
    				B=B->next;
    			} else
    				B=B->next;
    		}
    		if(strcasecmp(A->Num,B->Num)==0) {
    			A->i=A->i+B->i;
    			B->i=0;
    			M=B->P;
    			END->next=M;
    			END=M;
    		}
    		A=A->next;
    		B=A->next;
    		END->next=NULL;
    	}
    	HEAD=(Coord*)malloc(sizeof(Coord));
    	HEAD=A->P;
    	END=HEAD;
    	END->next=NULL;
    	number*Node;
    	Node=(number*)malloc(sizeof(number));
    	Node=head->next;
    	while(Node->next!=NULL) {
    		if(Node->i!=0) {
    			printf("%+10s   出现频率为%.2f 共%.0f次 : ",Node->Num,(Node->i)/sum,Node->i);
    			while(Node->P->next!=NULL) {
    				printf("在第%d行 第%d列、",Node->P->line,Node->P->row);
    				Node->P=Node->P->next;
    			}
    			printf("在第%d行 第%d列 ",Node->P->line,Node->P->row);
    			printf("\n");
    			Node=Node->next;
    		} else
    			Node=Node->next;
    	}
    	if(Node->i!=0) {
    		printf("%+10s   出现频率为%.2f 共%.0f次 : ",Node->Num,(Node->i)/sum,Node->i);
    		while(Node->P->next!=NULL) {
    			printf("在第%d行 第%d列、",Node->P->line,Node->P->row);
    			Node->P=Node->P->next;
    		}
    		printf("在第%d行 第%d列 ",Node->P->line,Node->P->row);
    	}
    }

    运行结果:

     

     

    展开全文
  • 统计英文单词出现次数,并顺序输出,采用二叉树,中序遍历输出。
  • 今天小编就为大家分享一篇python 文本单词提取和词频统计的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了python统计文本文件内单词数量的方法,涉及Python针对文本文件及字符串的相关操作技巧,需要的朋友可以参考下
  • 该程序由键盘输入一个符合上述约定的文本文件名和一个单词,计算该单词在该文件中出现的次数,并输出包含该单词的所有句子(按句子在文件中的先后次序,依次输出)。
  • 主要介绍了Python统计文本文件中英文单词出现个数的方法,结合实例形式总结分析了Python针对文本文件的读取,以及统计文本文件中英文单词个数的4种常用操作技巧,需要的朋友可以参考下
  • 主要介绍了python统计文本字符串里单词出现频率的方法,涉及Python字符串操作的相关技巧,需要的朋友可以参考下
  • 主要为大家详细介绍了C语言实现英文文本词频统计,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 文本英文单词统计

    2016-06-06 20:53:48
    可以用简单的图形界面显示文本所有英文单词的数目,并可以查询固定单词的个数
  • 测试文件统计在C:\ temp创建一个名为temp的文件夹创建要计算的文本文本文件
  • 本文实例为大家分享了python统计文本单词出现频率的具体代码,供大家参考,具体内容如下 #coding=utf-8 import os from collections import Counter sumsdata=[] for fname in os.listdir(os.getcwd()): if os....
  • 用IDEA编写MapReduce程序,生成Jar包,启动Hadoop,执行Jar包程序,在HDFS文件系统中查看单词统计和排序结果

    B站视频操作过程

    Hadoop实战——对单词文本进行统计和排序_哔哩哔哩_bilibili

    更多MapReduce设计案例地址

    https://github.com/yuanprogrammer/MapReduce-Case-Statistics

    目录

    一、前提准备工作

    启动hadoop集群

     windows可以访问

    二、整体流程

    三、核心代码讲解

    四、生成jar包上传

    五、运行程序

    Gitee仓库Hadoop项目下载地址

    其他系列技术教学、实战开发



    一、前提准备工作

    启动hadoop集群

    必须已经成功搭建好了hadoop集群,打开主节点和子节点全部虚拟机,启动hadoop

     windows可以访问

    关闭主节点虚拟机的防火墙,在windows的hosts文件添加配置信息

    二、整体流程

    整体流程如下

    程序内部执行过程如下

     

    三、核心代码讲解

    Mapper类

    将单词文本进行切割,切割成一个个的单词,写入到上下文中

    (1)按行读取,通过split函数进行切割,将切割出来的一个个单词放到数组ars中

    (2)遍历数组ars,将存在的单词数据存储到word中,然后将word写入到context上下文(使Redcue程序能访问到数据)

    ​​​​​​​

    package com.itcast;
    
    import java.io.IOException;
    import java.util.Date;
    
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Mapper;
    
    /**
     * FileName:    WordMapper
     * Author:      Yuan-Programmer
     * Date:        2021/11/8 23:29
     * Description:
     */
    // 创建一个 WordMapper类 继承于 Mapper抽象类
    public class WordMapper extends Mapper<Object, Text, Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();
    
        // Mapper抽象类的核心方法,三个参数
        public void map(Object key, // 首字符偏移量
                        Text value, // 文件的一行内容
                        Context context) // Mapper端的上下文,与 OutputCollector 和 Reporter 的功能类似
                throws IOException, InterruptedException {
            String[] ars = value.toString().split("['.;,?| \t\n\r\f]");
            for (String tmp : ars) {
                if (tmp == null || tmp.length() <= 0) {
                    continue;
                }
                word.set(tmp);
                System.out.println(new Date().toGMTString() + ":" + word + "出现一次,计数+1");
                context.write(word, one);
            }
        }
    }
    

    Reduce类(部分代码展示)

    (1)将每个单词统计次数结果进行求和合并,写入到map集合里

    (2)调用Utils工具类的sortValue方法对map集合进行排序

    (3)遍历排序好的map集合,依次写入到context上下文中

    ​​​​​​​

    package com.itcast;
    
    import java.io.IOException;
    import java.util.*;
    
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Reducer;
    
    /**
     * FileName:    WordReduce
     * Author:      Yuan-Programmer
     * Date:        2021/11/8 23:32
     * Description:
     */
    // 创建一个 WordReducer类 继承于 Reducer抽象类
    public class WordReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        private IntWritable result = new IntWritable(); // 用于记录 key 的最终的词频数
        HashMap<String, Integer> map = new HashMap();
    
        // Reducer抽象类的核心方法,三个参数
        public void reduce(Text key, // Map端 输出的 key 值
                           Iterable<IntWritable> values, // Map端 输出的 Value 集合(相同key的集合)
                           Context context) // Reduce 端的上下文,与 OutputCollector 和 Reporter 的功能类似
                throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) // 遍历 values集合,并把值相加
            {
                sum += val.get();
            }
            map.put(key.toString(), sum);
            System.out.println(new Date().toGMTString() + ":" + key + "出现了" + result);
        }
    
        @Override
        protected void cleanup(Context context) throws IOException, InterruptedException {
            //  根据map中的value进行排序
            Map<String, Integer> sortedMap = MapUtils.sortValue(map);
            Set<Map.Entry<String, Integer>> entries = sortedMap.entrySet();
            Iterator<Map.Entry<String, Integer>> it = entries.iterator();
            /**
             * 不设置count,对全部单词进行排序
             * 循环获取迭代器的Map对象,再获取对应K,V
             * 将K,V封装到上下文中
             */
            while (it.hasNext()) {
                //  获取Map
                Map.Entry<String, Integer> entry = it.next();
                String key = entry.getKey();
                Integer value = entry.getValue();
                //  封装k3,v3
                Text k3 = new Text();
                k3.set(key);
                IntWritable v3 = new IntWritable();
                v3.set(value);
                //  写入上下文
                context.write(k3, v3);
            }
        }
    }
    

     Utils类(对map进行排序)

     (1)继承Comparable类,复写compare方法

    (2)通过map<k,v>集合的value(也就是单词次数)进行排序

    (3)将排序好的map返回

    package com.itcast;
    
    /**
     * FileName:    MapUtils
     * Author:      Yuan-Programmer
     * Date:        2021/11/9 0:05
     * Description:
     */
    
    import java.util.*;
    
    /**
     •	Map工具类
     */
    public class MapUtils {
        /**
         –	根据Map的value值降序排序
         –	@param map
         –	@param@param@return
         */
        public static <K, V extends Comparable<? super V>> Map<K, V> sortValue(Map<K, V> map) {
            List<Map.Entry<K, V>> list = new ArrayList(map.entrySet());
            Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
                @Override
                public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                    /**
                     * o1-o2:升序
                     * o2-o1:降序
                     * 返回结果加上“-”表示取反操作(升序->降序,降序->升序)
                     */
                    int compare = (o1.getValue()).compareTo(o2.getValue());
                    return -compare;
                }
            });
    
            //将排序结果返回上一级
            Map<K, V> returnMap = new LinkedHashMap<K, V>();
            for (Map.Entry<K, V> entry : list) {
                returnMap.put(entry.getKey(), entry.getValue());
            }
            return returnMap;
        }
    }
    

    新建一个测试类测试一下,可以看到排序OK

    四、生成jar包上传

    先点击右边的 clean 清理一下,然后点击 package 生成打包jar包

    运行完毕,会在左边生成一个 target 的文件夹,展开可以看到生成jar包程序

    选中jar包,右键选择复制,粘贴到桌面

     打开 winscp 工具,连接主节点虚拟机,将刚刚粘贴在桌面的jar包拷贝到虚拟机里(路径自己选,知道在哪就行)

    打开虚拟机,跳转到刚刚复制的路径目录下,可以看到已经拷贝进来了

     

    五、运行程序

    (1)创建单词文本并上传

    在下面可以看到有一个words.txt文本,这是我之前创好的

    more指令查看文本,可以看到文本里有很多的英文单词

     (2)上传到HDFS文件系统

    首先创建一个文件夹存放统计前的单词文本(words.txt)

     将单词文本(words.txt)上传到刚刚创建的文件夹下

     执行jar包程序,hadoop   jar   jar包名称   包名称+主类名   输入路径   输出路径

     包名称+主类名如下

    回车执行命令,等待提示运行完毕,运行结束后

    打开HDFS文件系统的output目录下,就能看到输出结果,打开文件点击Download下载

    以文本方式打开,可以看到已经对单词进行了统计并且对其进行降序操作

    Gitee仓库Hadoop项目下载地址

    Gitee仓库地址:Hadoop实战项目源码集合: https://blog.csdn.net/weixin_47971206CSDN文章教学中的源码汇总集合

    其他系列技术教学、实战开发

    https://github.com/yuanprogrammer/MapReduce-Case-Statistics


    - 本次文章分享就到这,有什么疑问或有更好的建议可在评论区留言,也可以私信我
    - 感谢阅读~


    展开全文
  • 给定一段文本统计其中总单词数并输出各个单词及其出现次数,该程序能成功运行。
  • 文本文件单词统计

    千次阅读 2021-08-20 14:43:23
    编写一个文本文件单词统计的程序,包括建立文件、单词统计、单词查询、单词定位的功能。 【基本要求】 程序应先询问用户的 ID号(ID 号包括两个大写字母和4 位数字), 例如: 请输入用户 ID 号:AB1234 程序应对输入的 ...

    【问题描述】

    编写一个文本文件单词统计的程序,包括建立文件、单词统计、单词查询、单词定位的功能。

    【基本要求】

    程序应先询问用户的 ID号(ID 号包括两个大写字母和4 位数字),
    例如: 请输入用户 ID 号:AB1234 程序应对输入的 ID 号验证,符合 ID 号要求的格式,然后程序提示四种选择:

    (1) 建立文件 (2) 单词统计 (3) 单词查询及定位 (4) 退出

    注意:
    i) 文件至少包含50个英文单词(一定出现重复的单词,且一定包含数字)
    ii) 文档不规范,单词之间可能不只有一个空格,并且有加引号的一些单词“jiaozi” 加引号的单词算单词,但数字不算单词
    iii) 逐行扫描文本文件,计算文档中单词总数,及各个单词出现的频次,并且按照单词首字母abcd…… 的顺序排列,显示并生成soft.txt文件
    iv) 查询任意给出的单词是否存在,如果不存在,在屏幕上输出“查无此词!”;如果存在,显示单词 出现的总次数,并且详细列出其 出现的位置。

       例如:
       请您输入待查询的词:of
       单词 of 共出现了2次;
       第1次出现在第1行,第5个位置;
       第2次出现在第3行,第1个位置。
    

    【具体代码】

    public class total {
        public static void main(String[] args) throws IOException {
            Scanner scanf = new Scanner(System.in) ;
            System.out.println("请输入用户的 ID 号");
            String ID = scanf.next() ;
            while(true) {
                if(judge(ID)) {
                    System.out.println(""+ "(1) 建立文件\r\n" + "(2) 单词统计 \r\n" + "(3) 单词查询及定位\r\n"+"(4) 退出");
                    break;
                }
                else {
                    System.out.println("ID格式错误,请重新输入");
                    ID = scanf.next() ;
                }
            }
    
            //不执行退出时始终为真
            boolean rand = true ;
            //选项
            String choice;
            List<String> list = new ArrayList<>();
            while(rand) {
                choice = scanf.next() ;
                switch(choice) {
                    case "1": {
                        System.out.println("开始建立文件");
                        //每次读入一行
                        BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));
    
                        String a;
                        while(true){
                            a = buffer.readLine();;
                            if("-1".equals(a)) {
                                break;
                            } else {
                                list.add(a);
                            }
                        }
                        createContentFile(list);
                        createSoftFile(list);
                        System.out.println("创建成功");
                        System.out.println(""+ "(1) 建立文件\r\n" + "(2) 单词统计 \r\n" + "(3) 单词查询及定位\r\n"+"(4) 退出");
                        break;
                    }
    
                    case "2":{
                        System.out.println("开始单词统计");
                        readFile();
                        System.out.println(""+ "(1) 建立文件\r\n" + "(2) 单词统计 \r\n" + "(3) 单词查询及定位\r\n"+"(4) 退出");
                        break;
                    }
                    case "3":{
                        System.out.println("开始单词查询及定位") ;
                        System.out.println("请您输入待查询的词:");
                        String check = scanf.next();
                        while (!"-1".equals(check)){
                            checkWord(list, check);
                            System.out.println("请您输入待查询的词:  输入-1结束");
                            check = scanf.next();
                        }
    
                        System.out.println(""+ "(1) 建立文件\r\n" + "(2) 单词统计 \r\n" + "(3) 单词查询及定位\r\n"+"(4) 退出");
                        break;
    
                    }
                    case "4":{
                        System.out.println("成功退出") ;
                        rand = false;
                        break;
    
                    }
    
                    default: System.out.println(""+ "(1) 建立文件\r\n" + "(2) 单词统计 \r\n" + "(3) 单词查询及定位\r\n"+"(4) 退出");
    
                }
            }
        }
        /**判断id格式是否正确*/
        public static boolean judge(String id) {
    
            String regex = "^[A-Z]{2}[0-9]{4}$";
            boolean flag = id.matches(regex);
            return flag;
    
        }
    
        /**创建ContentFile*/
        public static void createContentFile(List<String> list) throws IOException {
            String filePath = "G:\\文本文件单词统计1\\生成文本";
            File dir = new File(filePath);
            // 一、检查放置文件的文件夹路径是否存在,不存在则创建
            if (!dir.exists()) {
                dir.mkdirs();// mkdirs创建多级目录
            }
            File checkFile = new File(filePath + "/content.txt");
            FileWriter writer = null;
            try {
                // 二、检查目标文件是否存在,不存在则创建
                if (!checkFile.exists()) {
                    checkFile.createNewFile();// 创建目标文件
                }
                // 三、向目标文件中写入内容
                // FileWriter(File file, boolean append),append为true时为追加模式,false或缺省则为覆盖模式
                //先清空文件
                writer = new FileWriter(checkFile);
                writer.append("");
                writer.flush();
    
                //再追加写入
                writer = new FileWriter(checkFile, true);
                for (String content : list){
                    writer.append(content);
                }
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (null != writer) {
                    writer.close();
                }
            }
        }
    
        /**创建SoftFile*/
        public static void createSoftFile(List<String> list) throws IOException {
            //String为单词,countNum为单词出现的次数
            Map<String, Integer> map = new HashMap<>();
            int countNum = 0;
            //正则表达式
            Pattern p = Pattern.compile("\\b[a-zA-Z-]+\\b");
            Matcher m = p.matcher(list.toString());
            //find方法扫描输入序列以查找与该模式匹配的下一个子序列
            while(m.find()){
                //String group():返回匹配到的子字符串
                String mstr = m.group();
                //containsKey() 判断Map集合对象中是否包含指定的键名
                if(map.containsKey(mstr)){
                    map.put(mstr, map.get(mstr)+1);
                }else{
                    map.put(mstr, 1);
                }
                countNum++;
            }
            Set<String> set = map.keySet();
            String[] strings = set.toArray(new String[set.size()]);
    
            //忽略大小写排序
            Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER);
    
    
            String filePath = "G:\\文本文件单词统计1\\生成文本";
            File dir = new File(filePath);
            // 一、检查放置文件的文件夹路径是否存在,不存在则创建
            if (!dir.exists()) {
                dir.mkdirs();// mkdirs创建多级目录
            }
            File checkFile = new File(filePath + "/soft.txt");
            FileWriter writer = null;
            try {
                // 二、检查目标文件是否存在,不存在则创建
                if (!checkFile.exists()) {
                    checkFile.createNewFile();// 创建目标文件
                }
                // 三、向目标文件中写入内容
                // FileWriter(File file, boolean append),append为true时为追加模式,false或缺省则为覆盖模式
                writer = new FileWriter(checkFile, false);
                writer.append("共有单词:" + countNum + "个" + "\n");
                for (String key : strings){
                    writer.append(key + ":" + map.get(key) + "次" + "\n");
                }
    
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (null != writer) {
                    writer.close();
                }
            }
        }
    
        /**读取文件*/
        public static void readFile() {
            FileReader fileReader = null;
            BufferedReader br = null;
            String line;
            try {
                // 判断文件是否存在
                File testFile = new File("G:\\文本文件单词统计1\\生成文本\\soft.txt");
                if(!testFile.exists()) {
                    System.out.println(testFile.getName() + "文件尚未生成");
                }
                // 读取文件
                fileReader = new FileReader(testFile);
                br = new BufferedReader(fileReader);
                line = br.readLine();
                while(line != null) {
                    System.out.println(line);
                    line = br.readLine();
                }
            }catch(Exception e) {
                e.printStackTrace();
            }
            finally {
                if(br != null) {
                    try {
                        br.close();
                    }catch(Exception e) {
                        e.printStackTrace();
                        br = null;
                    }
                }
                if(fileReader != null) {
                    try {
                        fileReader.close();
                    }catch(Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        /**查询单词*/
        public static void checkWord(List<String> list, String check){
            Map<Integer,Integer> map = new HashMap<>();
            int count = 0;
            for (int i = 0 ; i < list.size() ; i++){
                int flag = list.get(i).indexOf(check);
                if (flag != -1){
                    map.put(i+1, flag+1);
                    count++;
                }
            }
            if (count == 0){
                System.out.println("查无此词!");
            }else {
                System.out.println("单词" + check+"共出现了" + count + "次;");
                int a = 1;
                for(Map.Entry<Integer, Integer> entry : map.entrySet()){
                    System.out.println("第" + a + "次" + "出现在第" + entry.getKey() + "行," + "第" + entry.getValue() + "个位置");
                    a++;
            }
    
            }
        }
    
    
    }
    

    【运行示例】

    请输入用户的 ID 号
    AD1234
    (1) 建立文件
    (2) 单词统计 
    (3) 单词查询及定位
    (4) 退出
    1
    开始建立文件
    what is the most important thing in the world?
    I think it is health
    You can take away our money,house,car,or even our clothes and we can survive.
    That is why we always try to eat in a healthy way and exercise regularlg.
    0
    -1
    创建成功
    (1) 建立文件
    (2) 单词统计 
    (3) 单词查询及定位
    (4) 退出
    2
    开始单词统计
    共有单词:45个
    a:1次
    always:1次
    and:2次
    away:1次
    can:2次
    car:1次
    clothes:1次
    eat:1次
    even:1次
    exercise:1次
    health:1次
    healthy:1次
    house:1次
    I:1次
    important:1次
    in:2次
    is:3次
    it:1次
    money:1次
    most:1次
    or:1次
    our:2次
    regularlg:1次
    survive:1次
    take:1次
    That:1次
    the:2次
    thing:1次
    think:1次
    to:1次
    try:1次
    way:1次
    we:2次
    what:1次
    why:1次
    world:1次
    You:1次
    (1) 建立文件
    (2) 单词统计 
    (3) 单词查询及定位
    (4) 退出
    3
    开始单词查询及定位
    请您输入待查询的词:
    we
    单词we共出现了2次;
    第1次出现在第3行,第63个位置
    第2次出现在第4行,第13个位置
    请您输入待查询的词:  输入-1结束
    that
    查无此词!
    请您输入待查询的词:  输入-1结束
    That
    单词That共出现了1次;
    第1次出现在第4行,第1个位置
    请您输入待查询的词:  输入-1结束
    -1
    (1) 建立文件
    (2) 单词统计 
    (3) 单词查询及定位
    (4) 退出
    4
    成功退出
    
    Process finished with exit code 0
    
    展开全文
  • Linux系统中想要统计文本的行数、单词和字符数量,该怎么统计呢?我们可以使用SecureCRT来统计,下面我们就来看看详细的教程。1、启动Linux系统,用SecureCRT(或者其他的ssh工具,如xshell等)连上Linux系统。也可以...
  • 【C++】文本文件单词统计、定位

    千次阅读 2021-05-28 01:20:15
    文本文件单词统计 1.1 【问题描述】 编写一个文本文件单词统计的程序,包括建立文件、单词统计、单词查询、单词定位的功能。 1.2 【基本要求】 程序应先询问用户的ID号(ID 号包括两个大写字母和4 位数字),例如: 请...
  • 统计文本单词的个数

    千次阅读 2021-05-18 15:16:24
    统计一行文本单词个数:输入一行字符,统计其中单词的个数.个单词之间用空格分隔,空格数可以是多个,代码部分: #includeint main(){int count=0;char temp;bool letter;letter=0;//letter=0为在单词里(单词没...
  • 文本文件单词统计(C语言)

    千次阅读 2021-07-27 21:17:22
    文本文件单词统计(C语言) 本人目前还是一位在校大学生,写文章的目的是为了记录一下当前所学,与其他爱好者或从业者相互学习交流。文本文件单词统计这个题目是学校的一次课程设计中的一道,在编写时也是参考了很多...
  • hamlet单词统计代码

    2018-07-18 11:54:35
    Python,莎士比亚hamlet使用频率最高的单词统计代码,适用于英文文件的使用单词统计
  • 习题6-8 统计一行文本单词个数 (15分)** 本题目要求编写程序统计一行字符中单词的个数。所谓“单词”是指连续不含空格的字符串,各单词之间用空格分隔,空格数可以是多个。 输入格式: 输入给出一行字符。 输出...
  • 本文通过实例代码给大家介绍的C语言统计一篇英文短文中单词的个数,代码简单易懂,非常不错,具有参考借鉴价值,需要的朋友参考下吧
  • 手动实现一个单词统计MapReduce程序与过程原理分析 前言 我们知道,在搭建好hadoop环境后,可以运行wordcount程序来体验一下hadoop的功能,该程序在hadoop目录下的share/hadoop/mapreduce目录中,通过下面的命令: ...
  • 自动统计文本单词出现最多的单词
  • 数据挖掘中的基础部分,对英文文章进行统计!!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,230
精华内容 32,492
关键字:

文本单词统计