使用文件读写操作统计哈利波特英文版中的字母，单词，并按要求输出

要求如下：

1.将哈利波特英文电子版导入，并统计每个英文字母出现概率(区分大小写)，由大到小排序

2.统计该txt 文件中每个单词的个数，并按照要求输出频率最高的几个单词数目 和出现概率

 功能1：

输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列。

功能2：

指定目录，对目录下的每一个文件执行功能1 操作

功能3：

指定文件目录，但是会递归目录下的所有子目录，每个文件执行功能1的操作。

问题：

1.程序如何识别每一个单词： 当出现非字母符号时划分为一个单词，用正则表达式来分割句子， 形成单词；

            //非单词用来分割单词
            String [] words = str.split("[^(a-zA-Z)]+");

2.如何存储单词和后边的数据：使用Map 数组， key值设置为 String 存储单词 ，value 根据需要改变类型

//创建哈希表 记录数目
            Map<String,Integer> map =new HashMap<String,Integer>();

主要思想:

读取文件内的数据，将数据转换为char类型，区分大小写统计字母个数，于此同时统计字母总个数。

1.使用BufferedReader 读取的缓存流进行读取，将数据添加到字符串缓冲区 StringBuffer 当中，将字符串缓冲区中的数据转换为char类型进行存储，进行一个循环遍历，用Character.isLetter() 方法判断是否是字母，进而用Character.isLowerCase（）判断是否是小写字母，用数组存储每个字母的出现次数，数组下标  如果是小写字母，则数组下标为 该字符(a-'a')(使用ASCII码表) 下标为0-25的存储小写字母，0-26存储大写字母，大写字母下标表示方法： a-'A'+26 ;

重新定义一个double 数组，长度为52，按顺序存储每个单词出现的频率百分比。 创建一个map 数组，key 存储 英文字母， value 存储 频率百分比。 定义一个list集合，里面存储Map类型 ，调用 Collections.sort（）方法 进行 排序 ，遍历List 集合输出 

key与value的 值。

 2.将录入的单词首先存到String数组当中，然后遍历String 数组，如果没有该单词的存储就创建一个map存储，如果已有该单词value+1，于此同时赋值number为单词总个数.

遍历完成，针对 map数组的value 值进行排序，最后按要求输出出现次数频率最高的几个单词，以及根据要求输出的出现概率。

功能1：

调用要求2的数据，自定义一个 hashtable的排序方法（哈哈，本人目前还没有搞明白。。。。），按照功能进行排序

功能2：

用file的isFile 判断是路径指向是否是文件，如果是文件则执行功能1，如果不是则将该目录下的文件存储到File 类型数组，进行遍历并执行功能1.

功能3；

与功能2类似，如果路径指向目录，则遍历目录，如果遇到目录则继续遍历，不是就执行功能1.

源码如下：

package com.FileReaderWriter;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

/** 
 *  信1805-2
 *  读取小说 并排序字母出现概率
 * @author cuixingyu
 *  按要求输出出现频率最高的单词和概率
 */
public class FileReaderWriter {
    
    //查找单词并按要求输出
    public static void word(String c) throws Exception {
    
            File file =new File(c);
            //导入路径
            FileReader fr=new FileReader(file);
            //带缓冲的输出流
            BufferedReader br=new BufferedReader(fr);
            //构造一个没有字符的字符串缓冲区，初始容量为16个字符
            StringBuffer sb= new StringBuffer();
            String text=null;
            //将读入的一行信息存储到text 中
            while((text=br.readLine())!=null) {
                //将读取出的字符text追加到StringBuffer 的 sb流中
                sb.append(text);
            }
            //关闭读入流
            br.close(); 
            
            //将sb缓存流中的所有单词转换为String 类型 然后变为小写
            String str = sb.toString().toLowerCase();
            //非单词用来分割单词
            String [] words = str.split("[^(a-zA-Z)]+");
            //创建哈希表 记录数目
            Map<String,Integer> map =new HashMap<String,Integer>();
            // forreach 语句，均可转换为for循环语句     for（元素类型    元素变量 x：遍历对象obj）
            double number=0;
            double k=0;
            for(String word :words){  
                if(map.get(word)==null){  // 若不存在说明是第一次，则加入到map,出现次数为1
                    map.put(word,1);
                    number++;
                    k++;
                }else{
                    map.put(word,map.get(word)+1);  // 若存在，次数累加1
                    number++;
                }
            }
            
            //排序
            //使用list集合 定义一个数组类型 list集合里放Map类型 每个Map的key 为String类型 对应的value为Integer 类型
            //map.entrySet()  返回此地图中包含的映射的Set视图。   ??
             List<Map.Entry<String ,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(map.entrySet()); 
            
             Comparator<Map.Entry<String,Integer>> comparator = new Comparator<Map.Entry<String, Integer>>() {
                 public int compare(Map.Entry<String, Integer> left, Map.Entry<String, Integer> right) 
                 {
                     return (left.getValue().compareTo(right.getValue()));
                  }
                };
                
                //排序方法 默认为 升序
                
                
                Collections.sort(list,comparator);
                System.out.println("单词总个数："+number);
                System.out.println("不相同单词个数："+k);
                System.out.println("请输入要查询的位数N：");
                Scanner sc=new Scanner(System.in);
                int n=sc.nextInt();
                for(int j=0;j<n;j++) {
                    double b=(list.get(list.size()-j-1).getValue()/number)*100;
                    System.out.println(list.get(list.size()-j-1).getKey() +":"+list.get(list.size()-j-1).getValue()+" "+String.format("%.2f", b)+"%");  //输出结果
                }
                
                
                //找寻文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列
                Hashtable<String,Integer> hashtable=new Hashtable<String,Integer>();
                
                for(String word :words){  
                    // 若不存在说明是第一次，则加入到map,出现次数为1
                    if(hashtable.get(word)==null){  
                        hashtable.put(word,1);
                    }else{
                        // 若存在，次数累加1
                        hashtable.put(word,hashtable.get(word)+1);  
                    }
                }
                //把哈希表排序
                mapValueSort((Hashtable<String,Integer>)hashtable); //把哈希表排序
    }
    //自定义哈希排序 输出按照个数 字母表排序
    private static void mapValueSort(Hashtable<String, Integer> hashtable) {
        // TODO Auto-generated method stub
           List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(hashtable.entrySet());//创建集合list，并规范集合为哈希表类型，并用hashtable.entrySet()初始化
         //定义list排序函数 
           list.sort(new Comparator<Map.Entry<String, Integer>>() 
            {
             public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2)
             { 
                //比较两者之间字典序大小并其值赋给变量a
                 int a=o1.getKey().compareTo(o2.getKey());
                //比较两者之间次数的大小
                 if(o1.getValue() < o2.getValue())                    
                 {
                     return 1;                                        //若后者大返回1，比较器会将两者调换次序，此为降序
                 }
                else if((o1.getValue() == o2.getValue())||((o1.getValue()==1)&&(o2.getValue()==1)))    //若次数相同比较字典序
                {
                    if(a!=0&&a>0)                                    //字典序在前的在前面
                     {
                         return 1;
                     }
                }
                return -1;
               }
            });
            int k=0;
            double sum=0;
            for (Map.Entry<String, Integer> mapping :list) //遍历排序后的集合
            {

                    sum+=mapping.getValue();
            }
      
            System.out.println("功能1：输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列");
            for (Map.Entry<String, Integer> mapping :list) //遍历排序后的集合
            {
                System.out.println(mapping.getKey() + ":" + mapping.getValue());
            }
        
    }
    //查找字母并按要求输出。
    public void  character(String c) throws Exception {
        //导入路径
        FileReader fr=new FileReader(c);
        //带缓冲的输出流
        BufferedReader br=new BufferedReader(fr);
        //构造一个没有字符的字符串缓冲区，初始容量为16个字符
        StringBuffer sb= new StringBuffer();
        String text=null;
        //将读入的一行信息存储到text 中
        while((text=br.readLine())!=null) {
            //将读取出的字符text追加到StringBuffer 的 sb流中
            sb.append(text);
        }
        //关闭读入流
        br.close(); 
        
        //将字符串转换为单个的字符
        char[] str=sb.toString().toCharArray();
        
           //统计单词个数        
           double number=0;
           //计数数组
           int []count=new int [52];
          
           for(int i=0;i<str.length;i++) {
               //判断该字符是否时字母
            if(Character.isLetter(str[i])) {
                //判断是否时小写字母
                if(Character.isLowerCase(str[i])) 
                {
                    count[str[i]-'a']++;
                    number++;
                }else {
                    count[str[i]-'A'+26]++;
                    number++;
                   }
            }
          }
           
           //计算概率
          double []s=new double [52] ; 
          for(int k=0;k<52;k++) {
              //化为百分比
              s[k]=count[k]/number*100;
           }
          //定义哈希表
          Map<String,Double> map =new HashMap<String,Double>();
          
           for(int i=0;i<s.length;i++) {
               
               //哈希表 前一个记录字母，后一个记录概率
               if(i<26) {
                   //小写字母统计
                   char q=(char)(i+97);
                   String key=String.valueOf(q);
               map.put(key, s[i]);
               }else {
                   //大写字母统计
                   char q=(char)(i+65-26);
                   String key=String.valueOf(q);
               map.put(key, s[i]);
               }
           }
          
      
           //排序 默认为升序
           
           List<Map.Entry<String,Double>> list = new ArrayList<Map.Entry<String,Double>>(map.entrySet()); 
            
             Comparator<Map.Entry<String,Double>> comparator = new Comparator<Map.Entry<String,Double>>() {
                 public int compare(Map.Entry<String,Double> left, Map.Entry<String,Double> right) 
                 {
                     return (left.getValue().compareTo(right.getValue()));
                  }
                };
                
            
                Collections.sort(list,comparator); 
               
                for(int j=0;j<s.length;j++) {
                    System.out.println(list.get(list.size()-j-1).getKey() +":"+String.format("%.2f", list.get(list.size()-j-1).getValue())+"%");  //输出结果
                }
        
    }
    
    //递归遍历目录下的所有子目录
    @SuppressWarnings("null")
    static void getPath(String a) throws Exception {
        FileReaderWriter test1=null; 
        File file = new File(a);
         
         File []array =file.listFiles();
         for(int i=0;i<array.length;i++) {
             //判断是否是目录
            if(array[i].isDirectory()) {
                 getPath(array[i].getPath());
             }else {
              word(array[i].getPath());     
              }
         }
    }
        

    public static void main(String[] args) throws Exception {
        FileReaderWriter test= new FileReaderWriter();
        String c="C://Users//cuixingyu//Desktop//Harry Potter and the Sorcerer's Stone.txt";
        String b="D://cxy//454";
        System.out.println("输出某个英文文本文件中 26 字母出现的频率，由高到低排列，并显示字母出现的百分比，精确到小数点后面两位：");
        test.character(c);
        
        
        
        /*File file = new File(c);
         if(file.isFile()) {
         System.out.println("功能1：输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列");
             test.word(c);
         }
          //指定文件目录，对目录下每一个文件执行  功能1的操作
         else {
         File []array =file.listFiles();
         for(int i=0;i<array.length;i++) {
         //判断是否是目录
            if(!array[i].isDirectory()) {
            System.out.println("功能1：输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列");
                test.word(array[i].getPath());
            }
         }
        
         }*/
        
        //递归遍历所给目录中的所有子目录，并进行功能1 操作
        File file = new File(b);
         if(file.isFile()) {
             System.out.println("功能1：输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列");
             test.word(b);
             }
         else {
             getPath(b);
         }
        }
}