文本文件 字母单词频率分析

（1）读入文件

（2）将每个字节赋值给字符串

（3）分析字母频率 比较没有的字母写入  已存在的+1

  (4)单词频率 从前向后遍历  遇到空格 写入字符串 string类型   比较与上通

package 文本字母使用频率;
import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
* 信1705-2 谢培龙 20173611 
**/
public class Letter {
public static void main(String[] args){
demo(new File("D:\\dd.txt"));
}
public static void demo(File file){
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());/*定义一个TreeMap(因为TreeMap是有序的，存入的键值都有自然比较顺序功能,默认的是从小到大顺序，所有这里传了一个反转的比较器)，键对应字符，值对应字符出现的次数**/
for(int x = 0;x<ch.length;x++){ //遍历ch 将ch中所有的字符存入一个Map集合中(TreeSet)，键对应字符，值对应字符出现的次数
char c = ch[x];
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();
System.out.println(k+"("+v+") ");
}
}
catch(IOException e){
System.out.println("文件读取错误");
}
finally{
try{
if(bfr!=null)
bfr.close();
}
catch(IOException e){
System.out.println("文件关闭错误");
}
}
long t1 = System.currentTimeMillis();
String s; 
BufferedReader br = null;
try {
String fileName1 = "d:\\dd.txt"; 
br = new BufferedReader(new FileReader(fileName1));
/**代码：
* String fileName1 = "e:/test.txt"; 
br = new BufferedReader(new FileReader(fileName1));
也可以写作：
File file = new File("e:/test.txt");
* br = new BufferedReader(new FileReader(file));
*/
StringBuffer sb = new StringBuffer(); 
//将文件内容存入StringBuffer中 
while((s = br.readLine()) != null) { 
sb.append(s); 
} 
//不区分大小写
String str = sb.toString().toLowerCase();
//分隔字符串并存入数组 (以，。空格分割)
String[] elements = str.split("[,.\\s]"); 
int count = 0; 
Map<String, Integer> myTreeMap = new TreeMap<String, Integer>(); 
//遍历数组将其存入Map<String, Integer>中 
for(int i = 0; i < elements.length; i++) { 
if(myTreeMap.containsKey(elements[i])) { 
count = myTreeMap.get(elements[i]); 
myTreeMap.put(elements[i], count + 1); 
} 
else { 
myTreeMap.put(elements[i], 1); 
} 
} 
/**
* 直接遍历Map输出
*/
System.out.println("直接遍历Map输出（无序）：");
for(Map.Entry<String, Integer> entry:myTreeMap.entrySet()){
System.out.println(entry.getKey()+":"+entry.getValue());
}
/**
* 对频率从大到小排序，然后输出
*/
System.out.println("对频率从大到小排序，然后输出：");
//将map.entrySet()转换成list 
List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(myTreeMap.entrySet()); 
//通过比较器实现排序 
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() { 
//降序排序 
@SuppressWarnings("unused")
public int compare1(Entry<String, Integer> o1, Entry<String, Integer> o2) throws IOException { 
FileOutputStream fos = new FileOutputStream("d:\\newfile.txt");

return o2.getValue().compareTo(o1.getValue());

// return o1.getValue().compareTo(o2.getValue()); //升序排序
}

@Override
public int compare(Entry<String, Integer> arg0, Entry<String, Integer> arg1) {
// TODO 自动生成的方法存根
return 0;
} 
}); 
FileOutputStream fos = new FileOutputStream("d:\\newfile.txt");
for(Map.Entry<String, Integer> map : list) {

System.out.print(map.getKey() + ":" + map.getValue());
String a= map.getKey();//将string转换为char类型
char b=a.charAt(0);
fos.write(b);
}
System.out.println("耗时：" + (System.currentTimeMillis() - t1) + "ms");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} 
}


}

}