原文档内容1.png这里使用字符缓冲流BufferedReader逐行读取文档中的内容，利用split方法将每一行的字符与数字分离，然后将字符部分作为key值数字部分作为value值存入HashMap，在HashMap中按value值进行降序排序后利用转换流OutputStreamWriter将Map中的内容重新输出到文件中

    1. import java.io.BufferedReader;
    2. import java.io.File;
    3. import java.io.FileReader;
    4. import java.io.IOException;
    5. import java.util.HashMap;
    6. import java.util.Map;
    8. public class savefile {
    9.         //将文件中的内容读入HashMap
    10.         Map<String, Integer> fTM() {
    11.                 Map<String, Integer> map = new HashMap<String, Integer>();
    12.                 File file = new File("F:\\Java\\IO Study 03\\test.txt");
    13.                 BufferedReader reader = null;
    14.                 try {
    15.                         reader = new BufferedReader(new FileReader(file));
    16.                         String tempString = null;
    17.                         // 一次读入一行，直到读入null为文件结束
    18.                         while ((tempString = reader.readLine()) != null) {
    19.                                 if(strArray.length > 1) {
    20.                                         int ic = Integer.parseInt(strArray[1]);
    21.                                         map.put(strArray[0], ic);
    22.                                 }
    23.                         }
    24.                 reader.close();
    25.                 } catch (IOException e) {
    26.                         e.printStackTrace();
    27.                 } finally {
    28.                         if (reader != null) {
    29.                         try {
    30.                                 reader.close();
    31.                         } catch (IOException e1) {
    33.                                 }
    34.                         }
    35.                 }
    36.                 return map;
    37.         }
    38. }
    1. import java.util.*;
    3. public class MapSort {
    4.     // Map按value值降序排序
    5.     public static <K, V extends Comparable<? super V>> Map<K, V> sortDescend(Map<K, V> map) {
    6.         List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
    7.         Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
    8.             @Override
    9.             public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
    10.                 int compare = (o1.getValue()).compareTo(o2.getValue());
    11.                 return -compare;
    12.             }
    13.         });
    15.         Map<K, V> returnMap = new LinkedHashMap<K, V>();
    16.         for (Map.Entry<K, V> entry : list) {
    17.             returnMap.put(entry.getKey(), entry.getValue());
    18.         }
    19.         return returnMap;
    20.     }
    21. }
    1. import java.io.FileOutputStream;
    2. import java.io.IOException;
    3. import java.io.OutputStreamWriter;
    4. import java.util.Map;
    6. public class save {
    7.     public static void saveMapToTxt(Map<String, Integer> map, String filePath){
    8.         OutputStreamWriter outFile = null;
    9.         FileOutputStream fileName;
    10.         try{
    11.             fileName = new FileOutputStream(filePath);
    12.             outFile = new OutputStreamWriter(fileName);
    13.             String str = "";
    14.             for(String key : map.keySet()){
    15.                 str += key + "-----------------------------------" + map.get(key) + "\n";
    16.             }
    17.             outFile.write(str);
    18.         } catch (IOException e) {
    19.             e.printStackTrace();
    20.         }finally{
    21.             try {
    22.                 outFile.flush();
    23.                 outFile.close();
    24.             } catch (IOException e) {
    25.                 e.printStackTrace();
    26.             }
    27.         }
    28.     }
    29. }

    排序后的文档内容
    2.png