实现对properties文件的有序读写

1. 自定义一个PropertiesUtil类，该类继承自Properties。PropertiesUtil提供一个返回由key按照存入顺序组成的List的方法，getKeyList()，这样问题一就解决了。那如何保证getKeyList()方法返回的就是有序的key组成的集合呢？我查看了一下Properties方法的源码，发现其setProperty()方法实际上就是调用了父类HashTable的put()方法，其次Properties在从文件中加载内容时是按照文件顺序进行读取，然后调用父类HashTable的put()方法进行储存。所以问题的解决办法就是PropertiesUtil持有一个私有的可以有序存储key的集合，然后重写父类的put()方法，在方法体中照常通过super.put()进行属性的存储，同时将key添加到存储key的集合中。

Properties提供有save()方法和store()方法可以将当前对象的内容存放到指定的输出流中，但它们的底层逻辑都是一样的。通过调用keys()方法获取一个Enumeration，然后对该Enumeration进行遍历，依次将对应的key和value写入到输出流中，所以要保证写入是有序的，就要保证遍历keys()返回的Enumeration时取出的元素key是有序的。所以解决方法是重写keys()方法，保证遍历返回的Enumeration时得到的key是有序的。完整代码如下：

1.   自定义一个PropertiesUtil类，该类继承自Properties。PropertiesUtil提供一个返回由key按照存入顺序组成的List的方法，getKeyList()，这样问题一就解决了。那如何保证getKeyList()方法返回的就是有序的key组成的集合呢？我查看了一下Properties方法的源码，发现其setProperty()方法实际上就是调用了父类HashTable的put()方法，其次Properties在从文件中加载内容时是按照文件顺序进行读取，然后调用父类HashTable的put()方法进行储存。所以问题的解决办法就是PropertiesUtil持有一个私有的可以有序存储key的集合，然后重写父类的put()方法，在方法体中照常通过super.put()进行属性的存储，同时将key添加到存储key的集合中。
   Properties提供有save()方法和store()方法可以将当前对象的内容存放到指定的输出流中，但它们的底层逻辑都是一样的。通过调用keys()方法获取一个Enumeration，然后对该Enumeration进行遍历，依次将对应的key和value写入到输出流中，所以要保证写入是有序的，就要保证遍历keys()返回的Enumeration时取出的元素key是有序的。所以解决方法是重写keys()方法，保证遍历返回的Enumeration时得到的key是有序的。完整代码如下：
   
    public class PropertiesUtil extends Properties {
       private static final long serialVersionUID = 1L;
       private List<Object> keyList = new ArrayList<Object>();
       /**
        * 默认构造方法
        */
       public PropertiesUtil() {
       }
       /**
        * 从指定路径加载信息到Properties
        * @param path
        */
       public PropertiesUtil(String path) {
           try {
               InputStream is = new FileInputStream(path);
               this.load(is);
           } catch (FileNotFoundException e) {
               e.printStackTrace();
               throw new RuntimeException("指定文件不存在！");
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
       /**
        * 重写put方法，按照property的存入顺序保存key到keyList，遇到重复的后者将覆盖前者。
        */
       @Override
       public synchronized Object put(Object key, Object value) {
           this.removeKeyIfExists(key);
           keyList.add(key);
           return super.put(key, value);
       }
       /**
        * 重写remove方法，删除属性时清除keyList中对应的key。
        */
       @Override
       public synchronized Object remove(Object key) {
           this.removeKeyIfExists(key);
           return super.remove(key);
       }
       /**
        * keyList中存在指定的key时则将其删除
        */
       private void removeKeyIfExists(Object key) {
           keyList.remove(key);
       }
       /**
        * 获取Properties中key的有序集合
        * @return
        */
       public List<Object> getKeyList() {
           return keyList;
       }
       /**
        * 保存Properties到指定文件，默认使用UTF-8编码
        * @param path 指定文件路径
        */
       public void store(String path) {
           this.store(path, "UTF-8");
       }
       /**
        * 保存Properties到指定文件，并指定对应存放编码
        * @param path 指定路径
        * @param charset 文件编码
        */
       public void store(String path, String charset) {
           if (path != null && !"".equals(path)) {
               try {
                   OutputStream os = new FileOutputStream(path);
                   BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os, charset));
                   this.store(bw, null);
                   bw.close();
               } catch (FileNotFoundException e) {
                   e.printStackTrace();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           } else {
               throw new RuntimeException("存储路径不能为空!");
           }
       }
       /**
        * 重写keys方法，返回根据keyList适配的Enumeration，且保持HashTable keys()方法的原有语义，
        * 每次都调用返回一个新的Enumeration对象，且和之前的不产生冲突
        */
       @Override
       public synchronized Enumeration<Object> keys() {
           return new EnumerationAdapter<Object>(keyList);
       }
       /**
        * List到Enumeration的适配器
        */
       private class EnumerationAdapter<T> implements Enumeration<T> {
           private int index = 0;
           private final List<T> list;
           private final boolean isEmpty;
           public EnumerationAdapter(List<T> list) {
               this.list = list;
               this.isEmpty = list.isEmpty();
           }
           public boolean hasMoreElements() {
               //isEmpty的引入是为了更贴近HashTable原有的语义，在HashTable中添加元素前调用其keys()方法获得一个Enumeration的引用，
               //之后往HashTable中添加数据后，调用之前获取到的Enumeration的hasMoreElements()将返回false，但如果此时重新获取一个
               //Enumeration的引用，则新Enumeration的hasMoreElements()将返回true，而且之后对HashTable数据的增、删、改都是可以在
               //nextElement中获取到的。
               return !isEmpty && index < list.size();
           }
           public T nextElement() {
               if (this.hasMoreElements()) {
                   return list.get(index++);
               }
               return null;
           }
       }
   }