精华内容
下载资源
问答
  • Java 统计英文单词

    千次阅读 2013-11-25 19:25:49
    import java.util.*; public class OutputWordMess { public static void main(String[] args) { Vector allWord,noSameWord; WordStatistic statistic=new WordStatistic(); statisti
    package second;
    import java.util.*;
    public class OutputWordMess {
    	public static void main(String[] args) {
    		Vector<String> allWord,noSameWord;
    		WordStatistic statistic=new WordStatistic();
    		statistic.setFileName("hello.txt");
    		statistic.WordStatistic();
    		allWord=statistic.getAllWord();
    		noSameWord=statistic.getNoSameWord();
    		System.out.println("共有"+allWord.size()+"个英文单词");
    		System.out.println("有"+noSameWord.size()+"个互不相同英文单词");
    		System.out.println("按出现的频率排列:");
    		int count[]=new int[noSameWord.size()];
    		for(int i=0;i<noSameWord.size();i++){
    			String s1=noSameWord.elementAt(i);
    			for(int j=0;j<allWord.size();j++){
    				String s2=allWord.elementAt(j);
    				if(s1.equals(s2))
    					count[i]++;
    			}
    		}
    		for(int m=0;m<noSameWord.size();m++){
    			for(int n=m+1;n<noSameWord.size();n++){
    				if(count[n]>count[m]){
    					String temp=noSameWord.elementAt(m);
    					noSameWord.setElementAt(noSameWord.elementAt(n), m);
    					noSameWord.setElementAt(temp, n);
    					int t=count[m];
    					count[m]=count[n];
    					count[n]=t;
    				}
    			}
    		}
    		for(int m=0;m<noSameWord.size();m++){
    			double frequency=(1.0*count[m])/allWord.size();
    			System.out.printf("%s:%-7.3f", noSameWord.elementAt(m),frequency);
    		}
    	}
    }
    
    
    import java.io.*;
    import java.util.*;
    public class WordStatistic {
    		Vector<String> allWord,noSameWord;
    		File file=new File("english.txt");
    		Scanner sc=null;
    		String regex;
    	WordStatistic (){
    			allWord=new Vector<String>();
    			noSameWord=new Vector<String>();
    			regex="[\\s\\d\\p{Punct}]+";//正则表达式
    			try{
    				sc=new Scanner(file);
    				sc.useDelimiter(regex);
    			}
    			catch(IOException exp){
    				System.out.println(exp.toString());
    			}
    		}
    		void setFileName(String name){
    			file=new File(name);
    			try{
    				sc=new Scanner(file);
    				sc.useDelimiter(regex);
    			}
    			catch(IOException exp){
    				System.out.println(exp.toString());
    			}
    	}
    
    	void WordStatistic() {
    		// TODO Auto-generated method stub
    		try{
    			while(sc.hasNext()){
    				String word=sc.next();
    				allWord.add(word);
    				if(!noSameWord.contains(word))
    					noSameWord.add(word);
    			}
    		}
    		catch(Exception e){}
    	}
    	public Vector<String>getAllWord(){
    	return allWord;
    	}
    	public Vector<String>getNoSameWord(){
    		return noSameWord;
    	}
    }
    

    展开全文
  • 第十章 实验统计英文单词

    千次阅读 2018-05-20 17:53:49
    实验目的:使用Scanner类解析文件我的目的······:上传一个运行没错结果错误但是我现在不想改但是又怕忘记的程序Wordstatistic.javaimport java.io.*; import java.util.*; public class wordstatistic{ ...

    实验目的:使用Scanner类解析文件

    我的目的······:上传一个运行没错结果错误但是我现在不想改但是又怕忘记的程序

    Wordstatistic.java

    import java.io.*;
    import java.util.*;
    public class wordstatistic{
        Vector<String> allWord,noSameWord;//构造函数  s
        File file=new File("english.txt");
        Scanner sc=null;//声明Scanner sc,在后面【代码1】中创建该对象
        String regex;
    
        public wordstatistic() {
        allWord=new Vector<String>();
        noSameWord=new Vector<String>();
        regex="[\\s\\d\\p{Punct}]+";//regex是由空格、数字和符号(!"#%&'等)组成的正则表达式
        try{
            sc=new Scanner(file);
            sc.useDelimiter(regex);
        }
        catch(IOException exp){
            System.out.println(exp.toString());
        }
        }
        void setFileNama(String name){
            file=new File(name);
            try{
                sc=new Scanner(file);
                sc.useDelimiter(regex);
            }
            catch(IOException exp){
                System.out.println(exp.toString());
            }
        }
        public void wordstatistic(){
            try{
                while(sc.hasNext()){
                    String word=sc.next();
                    /*hasNext()和Next()效果其实是一样的,系统都会等待输入下一个字符,只是返回值不同,hasNext()会返回true,next()返回输入的字符*/
                    allWord.add(word);
                    if(noSameWord.contains(word))
                        noSameWord.add(word);
                }
            }
            catch(Exception e){
                
            }
        }
        public  Vector<String>getAllWord(){
            return allWord;
        }
        public Vector<String>getNoSameWord(){
            return noSameWord;
        }
    }
    main.java
    import java.util.*;
    public class Main {
        public static void main(String[] args) {
            Vector<String>allWord,noSameWord;
            wordstatistic statistic=new wordstatistic();
            statistic.setFileNama("hello.txt");
            statistic.wordstatistic();
            allWord=statistic.getNoSameWord();//getallWord如何定义?
            noSameWord=statistic.getNoSameWord();
            System.out.println("共有"+allWord.size()+"个英文单词");
            System.out.println("有"+noSameWord.size()+"个互不相同的英文单词");
            System.out.println("按出现频率排序:");
            int count[]=new int[noSameWord.size()];
            
            for(int i=0;i<noSameWord.size();i++){
                String s1=noSameWord.elementAt(i);
                for(int j=0;j<allWord.size();j++){
                    String s2=allWord.elementAt(j);
                    if(s1.equals(s2))
                        count[i]++;
                }
            }
            for(int m=0;m<noSameWord.size();m++){
                for(int n=m+1;n<noSameWord.size();n++){
                    if(count[n]>count[m]){
                        String temp=noSameWord.elementAt(m);
                        noSameWord.setElementAt(noSameWord.elementAt(n), m);
                        noSameWord.setElementAt(temp, n);
                        int t=count[m];
                        count[m]=count[n];
                        count[n]=t;
                    }
                }
            }
            for(int m=0;m<noSameWord.size();m++){
                double frequency=(1.0*count[m]/allWord.size());
                System.out.printf("%s:%-7.3f",noSameWord.elementAt(m),frequency);
                /*print\println\printf的区别
    
    print将它的参数显示在命令窗口,并将输出光标定位在所显示的最后一个字符之后。
    
    println 将它的参数显示在命令窗口,并在结尾加上换行符,将输出光标定位在下一行的开始。
    
    printf是格式化输出的形式。
    
                 * 
                 * 
                 System.out.printf("the number is: d",t);
    参照JAVA API的定义如下:
    'd' 整数结果被格式化为十进制整数
    'o' 整数结果被格式化为八进制整数
    'x', 'X' 整数结果被格式化为十六进制整数
    'e', 'E' 浮点结果被格式化为用计算机科学记数法表示的十进制数
    'f' 浮点结果被格式化为十进制数
    'g', 'G' 浮点根据精度和舍入运算后的值,使用计算机科学记数形式或十进制格式对结果进行格式化。
    'a', 'A' 浮点结果被格式化为带有效位数和指数的十六进制浮点数
    */
            }
        }
    }
    

    实验结果(错误的):


    实验感想:

    不想干了!脖子疼,就是个废柴。一开始连printf跟print都分不出来,后来还忘记创建getAllWord()函数,呵呵

    展开全文
  • 本周的实验要求在之前实现统计单词的基础之上(可以见之前博客的统计单词的那个实验),对其进行修改成所需要的格式,统计字母出现频率的功能,并按照一定的格式把最终结果的用特定的格式在文本中显示出来 统计过程的...

    本周的实验要求在之前实现统计单词的基础之上(可以见之前博客的统计单词的那个实验),对其进行修改成所需要的格式,统计字母出现频率的功能,并按照一定的格式把最终结果的用特定的格式在文本中显示出来

    统计过程的实现并不太麻烦,在原来的基础上导入导出函数的基础上修改成通用的类型,统计单词的那一部分的单个字符读取那一段加上统计字母的情况,并加上判断把大小写字母统一起来。

    同时,在统计单词的那里加上一个无用字母的表格。这样就可以统计有用意义的前n个最常用的单词了。

    实验的代码如下所示:

    package pipei;
    //洪鼎淇 20173627 信1705-3
    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.text.DecimalFormat;
    import java.util.HashMap;
    import java.util.Map;
    //哈利波特单词统计
    
    
    
    public class Pipei {
        public static Map<String,Integer> map1=new HashMap<String,Integer>();
        static int g_Wordcount[]=new int[27];
        static int g_Num[]=new int[27];
        
        static String []unUse=new String[] {
            "it",
            "in",
            "to",
            "of",
            "the",
            "and",
            "that",
            "for"
        };
        
        public static void main(String arg[]) {
            daoruFiles("piao.txt","tongji");
            traverseFolder2("C:\\Users\\Halo\\javatest\\pipei\\piao");
            
        }
        public static void daoruFiles(String a,String dc)
        {
            map1.clear();
            try {
                daoru(a);
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
                
            }
            String sz[];
            Integer num[];
            final int MAXNUM=10; //统计的单词出现最多的前n个的个数
            
            for(int i=0;i<g_Wordcount.length;i++)
            {
                g_Wordcount[i]=0;
                g_Num[i]=i;
            }
            
            sz=new String[MAXNUM+1];
            num=new Integer[MAXNUM+1];
            Pipei pipei=new Pipei();
            int account =1;
            //Vector<String> ve1=new Vector<String>();
            try {
                daoru(a);
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            System.out.println("英文单词的出现情况如下:");
            int g_run=0;
            
            for(g_run=0;g_run<MAXNUM+1;g_run++)
            {
                account=1;
                for(Map.Entry<String,Integer> it : Pipei.map1.entrySet())
                {
                    if(account==1)
                    {
                        sz[g_run]=it.getKey();
                        num[g_run]=it.getValue();
                        account=2;
                    }
                    if(account==0)
                    {
                        account=1;
                        continue;
                    }
                    if(num[g_run]<it.getValue())
                    {
                        sz[g_run]=it.getKey();
                        num[g_run]=it.getValue();
                    }
                    //System.out.println("英文单词: "+it.getKey()+" 该英文单词出现次数: "+it.getValue());
                }
                Pipei.map1.remove(sz[g_run]);
            }
            int g_count=1;
            String tx1=new String();
            String tx2=new String();
            for(int i=0;i<g_run;i++)
            {
                if(sz[i]==null)
                    continue;
                if(sz[i].equals(""))
                    continue;
                tx1+="出现次数第"+(g_count)+"多的单词为:"+sz[i]+"\t\t\t出现次数: "+num[i]+"\r\n";
                System.out.println("出现次数第"+(g_count)+"多的单词为:"+sz[i]+"\t\t\t出现次数: "+num[i]);
                g_count++;
            }
            try {
                daochu(tx1,dc+"2.txt");
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            
            //------------------------------
            int temp=g_Wordcount[0];
            int numtemp=0;
            for(int i=0;i<26;i++)
            {
                for(int j=i;j<26;j++)
                {
                    if(g_Wordcount[j]>g_Wordcount[i])
                    {
                        temp=g_Wordcount[i];
                        g_Wordcount[i]=g_Wordcount[j];
                        g_Wordcount[j]=temp;
                        numtemp=g_Num[i];
                        g_Num[i]=g_Num[j];
                        g_Num[j]=numtemp;
                        
                    }
                }
            }
            int sum=0;
            for(int i=0;i<26;i++)
            {
                sum+=g_Wordcount[i];
            }
            for(int i=0;i<26;i++)
            {
                char c=(char) ('a'+g_Num[i]);
                tx2+=c+":"+String.format("%.2f%% \r\n", (double)g_Wordcount[i]/sum*100);
            }
            try {
                daochu(tx2,dc+"1.txt");
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            
            //------------------------------
            
        }
        public static void daoru(String s) throws IOException
        {
            
            File a=new File(s);
            FileInputStream b = new FileInputStream(a);
            InputStreamReader c=new InputStreamReader(b,"UTF-8");
            String string2=new String("");
            while(c.ready())
            {
                char string1=(char) c.read();
                if(WordNum(string1)>=0)
                {
                    g_Wordcount[WordNum(string1)]+=1;
                }
                
                //------------------------
                if(!isWord(string1))
                {
                    if(!isBaseWord(string2))
                    {
                        if(map1.containsKey(string2.toLowerCase()))
                        {
                            Integer num1=map1.get(string2.toLowerCase())+1;
                            map1.put(string2.toLowerCase(),num1);
                        }
                        else
                        {
                            Integer num1=1;
                            map1.put(string2.toLowerCase(),num1);
                        }
                    }
                    string2="";
                }
                else
                {
                    if(isInitWord(string1))
                    {
                        string2+=string1;
                    }
                }
            }
            if(!string2.isEmpty())
            {
                if(!isBaseWord(string2))
                {
                    if(map1.containsKey(string2.toLowerCase()))
                    {
                        Integer num1=map1.get(string2.toLowerCase())+1;
                        map1.put(string2.toLowerCase(),num1);
                    }
                    else
                    {
                        Integer num1=1;
                        map1.put(string2.toLowerCase(),num1);
                    }
                }
                
                string2="";
            }
            c.close();
            b.close();
        }
        public static void daochu(String txt,String outfile) throws IOException
        {
            File fi=new File(outfile);
            FileOutputStream fop=new FileOutputStream(fi);
            OutputStreamWriter ops=new OutputStreamWriter(fop,"UTF-8");
            ops.append(txt);
            ops.close();
            fop.close();
        }
        public static boolean isWord(char a)
        {
            if(a<='z'&&a>='a'||a<='Z'&&a>='A'||a=='\'')
                return true;
            return false;
        }
        public static boolean isInitWord(char a)
        {
            if(a<='z'&&a>='a'||a<='Z'&&a>='A'||a>'0'&&a<'9'||a=='\'')
                return true;
            return false;
        }
        public static boolean isBaseWord(String word)
        {
            for(int i=0;i<unUse.length;i++)
            {
                if(unUse[i].equals(word)||word.length()==1)
                    return true;
            }
            return false;
        }
        public static int WordNum(char a)
        {
            if(a<='z'&&a>='a')
                return a-'a';
            else if(a<='Z'&&a>='A')
                return a-'A';
            return -1;
        }
        //----递归文件夹
        public static void traverseFolder2(String path) {
    
            File file = new File(path);
            if (file.exists()) {
                File[] files = file.listFiles();
                if (null == files || files.length == 0) {
                    System.out.println("文件夹是空的!");
                    return;
                } else {
                    for (File file2 : files) {
                        if (file2.isDirectory()) {
                            System.out.println("文件夹:" + file2.getAbsolutePath());
                            traverseFolder2(file2.getAbsolutePath());
                        } else {
                            System.out.println("文件:" + file2.getAbsolutePath());
                            String name=file2.getName();
                            daoruFiles(file2.getAbsolutePath(), file2.getParentFile()+"\\"+name.replace(".txt", "")+"tongji");
                            
                        }
                    }
                }
            } else {
                System.out.println("文件不存在!");
            }
        }
    
        
    }

    将飘的整本小说及其分章节放在一个文件夹中,最终的实验结果如下:

    tongji1位后缀的是文章字母构成比例(以整本飘的英文小说为例子):

    tongji2的实验结果是有意义单词的出现次数前10的排名:

    对整本飘小说处理的时间级别在1秒以内,处理大文件及其多文件的过程在测试过程中没有出现问题。

     

    转载于:https://www.cnblogs.com/halone/p/10809496.html

    展开全文
  • Problem Description从键盘输入一行字符(长度小于100),统计其中单词的个数,各单词以空格分隔,且空格数可以是多个。Input输入只有一行句子。仅有空格和英文字母构成。Output单词的个数。Sample Inputstable ...

    Problem Description

    从键盘输入一行字符(长度小于100),统计其中单词的个数,各单词以空格分隔,且空格数可以是多个。

    Input

    输入只有一行句子。仅有空格和英文字母构成。

    Output

    单词的个数。

    Sample Input

    stable marriage  problem Consists     of Matching members

    Sample Output

    7


    import java.util.Scanner;   
    public class Main {    
        
        public static void main(String[] args) {      
            Scanner reader = new Scanner(System.in); 
            String s = reader.nextLine();
            int n=1;
            for(int i=0; i<s.length()-1; i++) {
            	if(s.charAt(i)==' ' && s.charAt(i+1)!=' ') {
            		n++;
            	}
            }
            System.out.println(n);
        }         
    }    

    展开全文
  • 1)要统计单词的个数,就自己的对文章中单词出现的判断的理解来说是:当出现一个非字母的字符的时候,对前面的一部分字符串归结为单词 2)对于最后要判断字母出现的个数这个问题,我认为应该是要用到map比较合适吧...
  • Java-单词统计

    2018-03-22 20:09:20
    C语言实验——单词统计Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit StatisticProblem Description从键盘输入一行字符(长度小于100),统计其中单词的个数,各单词以空格分隔,且空格数可以是多个。...
  • 课程原地址:http://hbust.shiyanbar.com/course/91079上课老师:李歆实验时间:20180517地点:云桌面...需求:对下面原始数据进行处理,把文档中所有的英文单词进行统计相同单词的个数。原始数据:The ASF prov...
  • note4:Hadoop统计单词频数JAVA类编写
  • C语言实验——单词统计 Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Problem Description 从键盘输入一行字符(长度小于100),统计其中单词的个数,各单词以空格分隔,且空格数...
  • 从键盘输入一个英文句子,统计该句子中的英文单词个数,并找出所有单词存放到一个数组中。同时,输出该句子中的不同单词和重复单词以及它们的个数。 二、实验代码 package fighting; import java.util.Scanner; ...
  • Hadoop单词统计实验

    千次阅读 2020-03-22 12:39:34
    Hadoop单词统计实验 一、搭建思路 1. 使用前期搭建好的伪分布式hadoop系统(单节点部署方案)作为Hadoop的基础环境平台,如果对前期Hadoop基础平台搭建不熟悉可以关注CSDN的博客,有详细说明,详细地址如下:...
  • (1)要求编程建立一个文本文件,每个单词不包含空格且不跨行,单词由字符序列构成且区分大小写,统计给定单词在文本文件中出现的总次数,检索输出的某个单词出现在文本中的行号、在该行中出现的次数以及位置。...
  • java实验---统计元音

    2018-09-27 09:37:12
    统计每个元音字母在字符串中出现的次数。 Input 输入数据首先包括一个整数n,表示测试实例的个数,然后是n行长度不超过100的字符串。 Output 对于每个测试实例输出5行,格式如下: a:num1 e:num2 i:num3 ...
  • 第1步:输出单个文件中的前 N 个最常出现的...功能3:指定文件目录,是会递归遍历目录下的所有子目录的文件进行统计单词的功能。 功能4:输出出现次数最多的前 n 个单词, 例如,提示统计统计前多少名:输入10。...
  • 今天的上机以自学为主,以为实在对文件处理一点以不会。学会了对文件的读入和输出等...3 进行相同单词的比较统计 4输出单词的个数 源代码(部分): import java.io.BufferedReader; import java.io.FileNot...
  • MapReduce统计文件单词

    2020-12-24 08:46:57
    MapReduce统计文件单词目录一、 前言二、 前期准备工作1. 创建帐户Hadoop2. 设置hadoop密码3. 给hadoop用户增加管理员权限4. 更新 apt5. 安装vim6. 配置SSH三、 安装Java环境1.安装JDK2.此时验证一下jdk安装情况3....
  • 大二的java实验

    千次阅读 2018-05-16 18:43:48
    这里会附上我的仓库,进去下载我的 java实验_self,这个我写的实验,戳我到仓库地址java实验上到实验7,包括实验7,后边的没时间了,感觉还是有时间的话,自己学完吧,希望这些能帮到你!!!(我给出实验要求,一样...
  •  第0步:输出某个英文文本文件中 26 字母出现的频率,由高到低排列,并显示字母出现的百分比,精确到小数点后面两位。  不难看出,这个只要求字母出现的频率,那么我们在读取文件的时候是采取的一次性全部读取,...
  • Java实验的答案源程序

    2012-04-25 23:54:47
    (2)统计单词中含“or”字符串的单词数; (3)统计长度为3的单词数。 创建一个程序,输出今天的年、月、日。 提示:创建一个java.util.Date类的对象代表当前的系统日期,使用对象的getYear()方法、getMonth()方法...
  • java实验三.doc

    2021-08-13 16:28:45
    2、编写程序统计一个文件中的字符数(控制符‘\r’和‘\n’除外),单词数以及行数。单词由空格,制表符,回车,或者换行符分隔,文件名应该作为命令行参数被传递。 3、编写程序,使用OutputStream对象向output.dat...
  • 湘潭大学java实验

    千次阅读 2020-11-02 09:16:50
    java实验题第1题第2题第3题第4题第5题第6题第7题第8题第9题第10题第11题第12题 第1题 第2题 第3题 import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner reader=new ...
  • 单词统计

    2018-03-18 19:24:58
    C语言实验——单词统计Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit StatisticProblem Description从键盘输入一行字符(长度小于100),统计其中单词的个数,各单词以空格分隔,且空格数可以是多个。...
  • java实验1.doc

    2019-11-04 10:56:10
    1.配置Java开发及运行环境,调试运行”Hello, world!”程序。 2. 键盘输入长方形的长和宽,编程求长方形的面积和周长。 3. 编程实现,找出100以内所有素数并输出(每行输出5个数)以及它们和值(换行输出)。 4. ...
  • Java实验一实验报告

    2015-04-15 19:37:00
    实验Java开发环境的熟悉 一、实验内容 1. 使用JDK编译、运行简单的Java程序 2.使用Eclipse 编辑、编译、运行、调试Java程序 二、实验要求 1.没有Linux基础的同学建议先学习《Linux基础入门(新版)》《Vim...
  • 1.配置Java开发及运行环境,调试运行”Hello, world!”程序。 2. 键盘输入长方形的长和宽,编程求长方形的面积和周长。 3. 编程实现,找出100以内所有素数并输出(每行输出5个数)以及它们和值(换行输出)。 4. ...
  • 在scala模式下编写单词统计 二、实验过程 了解spark的构成 2、具体步骤 1、打开一个终端,启动hadoop hadoop@dblab-VirtualBox:/usr/local/hadoop/sbin$./start-all.sh 2、启动spark hadoop@dblab-V.....
  • Java实验报告三

    2019-09-28 07:34:27
    Java实验报告 班级 计科二班 学号 20188450 姓名 李代传 完成时间 2019.9.20 评分等级 实验三 String类的应用 实验目的 掌握类String类的使用; 学会使用JDK帮助文档; 实验内容...
  • Java实验

    2015-04-16 23:44:00
    一、实验内容 1. 使用JDK编译、运行简单的Java程序 2.使用Eclipse 编辑、编译、运行、调试Java程序 二、实验要求 1.没有Linux基础的同学建议先学习《Linux基础入门(新版)》《Vim编辑器》 课程 2.完成实验、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,582
精华内容 2,232
关键字:

java实验统计英文单词

java 订阅