单词统计（续）

这次实验是在上一次的基础上进行的更改，大致思路已经在上次博客中给出，这次只是在原有的基础上进行的小添加，字母数据非常简单在第一次时就已经实现了；按前n位输出只需要输出指定前n位就可以，因为在输出之前已经排好了序；未重复的只需要限制输出数量为1的就可以；过滤单词只需要判断是否存在过滤文件中的单词即可。代码如下：

package chachong2;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;


public class ChaChong22{
    public static void main(String [] args) throws Exception {
        while(true) {
            System.out.println("1为字母数据：");
            System.out.println("2为未重复单词数据：");
            System.out.println("3为前n项单词数据：");
            System.out.println("4为经过stop过滤的单词数据：");
            //play(new File("C:\Users\Lenovo\Desktop\"));
            Scanner input = new Scanner(System.in);
            BufferedReader br = new BufferedReader(new FileReader("C:\Users\Lenovo\Desktop\飘c1.txt"));
            BufferedReader br2 = new BufferedReader(new FileReader("C:\Users\Lenovo\Desktop\stopwords.txt"));
            StringBuffer sb = new StringBuffer();
            StringBuffer sb2 = new StringBuffer();
            
            String text =null;
            while ((text=br.readLine())!= null){
                sb.append(text);// 将读取出的字符追加到stringbuffer中
            }
            br.close();  // 关闭读入流

            String text2 =null;
            while ((text2=br2.readLine())!= null){
                sb2.append(text2);// 将读取出的字符追加到stringbuffer中
            }
            br2.close();  // 关闭读入流
            //飘文件的存储
            String str = sb.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
            String[] words = str.split("[^(a-zA-Z)]+");  // 非单词的字符来分割，得到所有单词
            Map<String ,Integer> map = new HashMap<String, Integer>() ;

            for(String word :words){
                if(map.get(word)==null){  // 若不存在说明是第一次，则加入到map,出现次数为1
                    map.put(word,1);
                }else{
                    map.put(word,map.get(word)+1);  // 若存在，次数累加1
                }
            }
            //stop文件的存储
            String str2 = sb2.toString().toLowerCase(); // 将stringBuffer转为字符并转换为小写
            String[] words2 = str2.split("[^(a-zA-Z)]+");  // 非单词的字符来分割，得到所有单词
            Map<String ,Integer> map2 = new HashMap<String, Integer>() ;

            for(String word2 :words2){
                map2.put(word2,1);
            }
          
            // 排序
            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()));
                }
            };
         // 排序
            List<Map.Entry<String ,Integer>> list2 = new ArrayList<Map.Entry<String,Integer>>(map2.entrySet());
            Comparator<Map.Entry<String,Integer>> comparator2 = 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);
            Collections.sort(list2,comparator2);
            for(int i=0;i<list2.size();i++){// 由高到低输出
                    System.out.println(list2.get(list2.size()-i-1).getKey() +":"+list2.get(list2.size()-i-1).getValue());
            }
            int nn=input.nextInt();
            switch(nn) {
            case 1:{
                zimu(new File("C:\Users\Lenovo\Desktop\飘c1.txt"));
                break;
            }
            case 2:{
                danci(list);
                break;
            }
            case 3:{
                int n=0;
                System.out.println("请输入n的值：");
                n=input.nextInt();
                qiandanci(list,n);
                break;
            }
            case 4:{
                stopdanci(list,list2);
            }
            }
            /*
            for(int i=0;i<list.size();i++){// 由高到低输出
                if(list.get(list.size()-i-1).getKey().equals("a")||list.get(list.size()-i-1).getKey().equals("an")||list.get(list.size()-i-1).getKey().equals("the")||list.get(list.size()-i-1).getKey().equals("of")||list.get(list.size()-i-1).getKey().equals("and")) {
                }else {
                    System.out.println(list.get(list.size()-i-1).getKey() +":"+list.get(list.size()-i-1).getValue());
                }
            }
    */
        }
        
    }
    static File[] play(File file){
        //获取当前文件夹下的所有子文件
        File[] files =file.listFiles();
        for (int i = 0; i < files.length; i++) {
            if (files[i].isFile()){
                //输出文件名
                String filename=files[i].getName();
                System.out.println("filename: "+filename);
            }
            else {
                play(files[i]);
            }
        }
        return files;
    }
    static void danci(List<Map.Entry<String ,Integer>> list) {
        System.out.println("未重复的单词有：");
        for(int i=0;i<list.size();i++){// 由高到低输出
            if(list.get(list.size()-i-1).getValue()==1) {
                System.out.print(list.get(list.size()-i-1).getKey() + "**");
            }
        }
    }
    static void qiandanci(List<Map.Entry<String ,Integer>> list,int n) {
        System.out.println("前" + n + "个单词为：");
        for(int i=0;i<n;i++){// 由高到低输出
                System.out.print(list.get(list.size()-i-1).getKey() +":"+list.get(list.size()-i-1).getValue() + "**"); 
        }
    }
    static void stopdanci(List<Map.Entry<String ,Integer>> list,List<Map.Entry<String ,Integer>> list2) {
        System.out.println("经stop的单词有：");
        for(int i=0;i<list.size();i++){// 由高到低输出
            if(chongfu(list.get(list.size()-i-1).getKey(),list2)) {
                System.out.print(list.get(list.size()-i-1).getKey() + "**");
            }
        }
    }
    static boolean chongfu(String string,List<Map.Entry<String ,Integer>> list) {
        for(int i=0;i<list.size();i++) {
            if(list.get(list.size()-i-1).getKey()==string) {
                return false;
            }
        }
        return true;
    }
    static void zimu(File file){
        double sum=0.0;
        BufferedReader bfr = null;   //定义字符读取(缓冲)流
        try{
            bfr = new BufferedReader(new FileReader(file));
            String value = null; 
            String newValue = "";    
            while((value = bfr.readLine())!=null){    //开始读取文件中的字符
                newValue = newValue+value;    //存入newValue变量中
            }
            char[] ch = newValue.toCharArray();//把newValue变成字符数组
            TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>(Collections.reverseOrder());
            for(int x = 0;x<ch.length;x++){   
                char c = ch[x];
                if((c>=65&&c<=90)||(c>=97&&c<=122)) {
                    sum++;
                    if(tm.containsKey(c)){  //如果TreeMap(tm)中有该键，则取出该键中的值，也就是出现的次数
                        int conut = tm.get(c);
                        tm.put(c,conut+1);  //存入把新值存入tm集合中，如果键相同的话， 新键会替换老键，值也随着变化了
                    }
                    else{
                        tm.put(c, 1);  //如果没有出现该键就说明是第一次出现，然后就存入1次
                    }
                }
            }
            //下面的是取出TreeMap(tm)中的键和值
            Set<Map.Entry<Character, Integer>> set = tm.entrySet();
            Iterator<Map.Entry<Character, Integer>> iter = set.iterator();
            while(iter.hasNext()){
                Map.Entry<Character, Integer> map = iter.next();
                char k = map.getKey();
                int v = map.getValue();
                double baifenbi=0.0;
                System.out.println(k+"("+v+")  ");
            }
        }
        catch(IOException e){
            System.out.println("文件读取错误");
        }
        finally{
            try{
                if(bfr!=null)
                    bfr.close();
            }
            catch(IOException e){
                System.out.println("文件关闭错误");
            }
        }
    }
    
}