Java Properties 解決中文亂碼和順序讀寫

1.簡單介紹

Java中有個比較重要的類Properties（Java.util.Properties），主要用於讀取Java的配置文件，各種語言都有自己所支持的配置文件，配置文件中很多變量是經常改變的，這樣做也是為了方便用戶，讓用戶能夠脫離程序本身去修改相關的變量設置。像Python支持的配置文件是.ini文件，同樣，它也有自己讀取配置文件的類ConfigParse，方便程序員或用戶通過該類的方法來修改.ini配置文件。在Java中，其配置文件常為.properties文件，格式為文本文件，文件的內容的格式是“鍵=值”的格式，文本注釋信息可以用"#"來注釋。

Properties類繼承自Hashtable，如下：

它提供了幾個主要的方法：

1. load(InputStream inStream)，從輸入流中讀取屬性列表（鍵和元素對）。通過對指定的文件（比如說上面的 test.properties 文件）進行裝載來獲取該文件中的所有鍵-值對。以供 getProperty(Stringkey)來搜索。
2. getProperty(String key)，用指定的鍵在此屬性列表中搜索屬性。也就是通過參數key，得到key所對應的value。
3. setProperty(String key, String value) ，調用 Hashtable 的方法 put 。他通過調用基類的put方法來設置 鍵-值對。
4. remove(String key)，用來刪除指定的鍵。
5. store (OutputStream out,String comments)，以適合使用load方法加載到Properties 表中的格式，將此 Properties 表中的屬性列表（鍵和元素對）寫入輸出流。與 load方法相反，該方法將鍵-值對寫入到指定的文件中去。
6. clear()，清除所有裝載的 鍵-值對。該方法在基類中提供。

2.讀取Properties文件

Java讀取Properties文件的方法有很多，詳細可參考：Java讀取Properties文件的六種方法
常用的有兩種：

通過java.lang.Class類的getResourceAsStream(String name)方法來實現

InputStream in = lnew BufferedInputStream(new FileInputStream(name));
Properties p = new Properties();
p.load(in);

使用class.getClassLoader()所得到的java.lang.ClassLoader的getResourceAsStream()方法

InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);
Properties p = new Properties();
p.load(in);

獲取resource資源文件

InputStream stream = ClassLoader.getSystemResourceAsStream(fileName)
String path = ClassLoader.getSystemResource(fileName).toURI().getPath()

3. 相關實例

下面介紹一些常用操作，方便加深對Properties的理解與記憶。
創建chan.properties

name=寧川
password=123456
email=[e-mail]

讀取properties

InputStream stream = ClassLoader.getSystemResourceAsStream(fileName);
InputStreamReader reader = new InputStreamReader(stream, charsetName);
properties.load(reader);

String email = properties.getProperty("email");

關於中文的問題：
上面可以看到，我們的name是中文，這是我們打印出來的值可能是亂碼的。
name=宁川

這時，我們首先要保證使用的IDEproperties編碼時UTF-8。
IDEA：文件->設置->編輯器->文件編碼
eclipse：右鍵該文件->properties

然后可以在讀取的時候指定編碼，或者讀取后再轉換編碼。
同樣，保存的時候也指定UTF-8.

InputStream stream = ClassLoader.getSystemResourceAsStream(fileName);
InputStreamReader reader = new InputStreamReader(stream, charsetName);
properties.load(stream);

String name;
name = new String(properties.getProperty("name", "小明").toString().getBytes(),"UTF-8");

關於Properties順序讀寫的問題：

Java 的 Properties 加載屬性文件后是無法保證輸出的順序與文件中一致的，因為 Properties 是繼承自 Hashtable 的， key/value 都是直接存在 Hashtable 中的，而 Hashtable 是不保證進出順序的。
總有時候會有關心順序一致的需求，恰如有 org.apache.commons.collections.OrderdMap（其實用 LinkedHashMap 就是保證順序）一樣，我們也想要有個 OrderdProperties。

import java.util.*;

public class OrderedProperties extends Properties {

    private static final long serialVersionUID = -4627607243846121965L;

    private final LinkedHashSet<Object> keys = new LinkedHashSet<Object>();

    @Override
    public synchronized Enumeration<Object> keys() {
        return Collections.<Object>enumeration(keys);
    }

    @Override
    public synchronized Object put(Object key, Object value) {
        keys.add(key);
        System.out.println("key=" + key);
        System.out.println("value=" + value);
        return super.put(key, value);
    }

    @Override
    public synchronized Object remove(Object key) {
        keys.remove(key);
        return super.remove(key);
    }

    @Override
    public Set<Object> keySet() {
        return keys;
    }

    @Override
    public Set<String> stringPropertyNames() {
        Set<String> set = new LinkedHashSet<String>();

        for (Object key : this.keys) {
            set.add((String) key);
        }
        return set;
    }
}

練習用的PropertiesUtils，包含一些常用操作。

import java.io.*;
import java.util.*;

public class PropertiesUtils {

    private Properties properties;
    private String fileName;
    private String charsetName = "UTF-8";
    private Boolean autoCommit = true;

    public PropertiesUtils(String name) {
        loadProperties(name);
    }

    public PropertiesUtils(String name, String charsetName) {
        this.charsetName = charsetName;
        loadProperties(name);
    }

    public Properties getProperties() {
        return properties;
    }

    public void setCharsetName(String charsetName) {
        this.charsetName = charsetName;
    }

    public String getCharsetName() {
        return charsetName;
    }

    public void setAutoCommit(Boolean autoCommit) {
        this.autoCommit = autoCommit;
    }

    public Boolean getAutoCommit() {
        return autoCommit;
    }

    /**
     * 加載properties
     * @param name 資源文件properties
     * @return
     */
    void loadProperties(String name) {
        fileName = name;
        InputStream stream = null;
        properties = new OrderedProperties();

        try {
            stream = ClassLoader.getSystemResourceAsStream(fileName);
            InputStreamReader reader = new InputStreamReader(stream, charsetName);
            properties.load(reader);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * properties轉map
     * @return Map<String, String>
     */
    public Map<String, String> getPropToMap() {
        Map<String, String> map = null;

        if (properties != null) {
            map = new HashMap<String, String>();
            Enumeration enumeration = properties.propertyNames();
            while (enumeration.hasMoreElements()) {
                String key = (String) enumeration.nextElement();
                String value = properties.getProperty(key);
                map.put(key, value);
            }
        }
        return map;
    }

    /**
     * 獲取key對應的值
     * @param key key
     * @return String
     */
    public String getProperty(String key) {
        return getProperty(key, null);
    }

    /**
     * 獲取key對應的值
     * @param key          key
     * @param defaultValue defaultValue
     * @return String
     */
    public String getProperty(String key, String defaultValue) {
        if (properties != null && !properties.isEmpty()) {
            return properties.getProperty(key, defaultValue);
        }
        return null;
    }

    /**
     * 更新配置
     * @param key   key
     * @param value vale
     * @return Boolean
     */
    public Boolean setProperty(String key, String value) {
        return setProperty(key, value, "");
    }

    /**
     * 更新配置
     * @param key      key
     * @param value    value
     * @param comments 說明
     * @return Boolean
     */
    public Boolean setProperty(String key, String value, String comments) {
        properties.setProperty(key, value);
        if (autoCommit) {
            return saveProperties(comments);
        }
        return true;
    }

    /**
     * 刪除key
     * @param key key
     * @return Boolean
     */
    public Boolean remove(String key) {
        return remove(key, "");
    }

    /**
     * 刪除key
     * @param key      key
     * @param comments 說明
     * @return Boolean
     */
    public Boolean remove(String key, String comments) {
        properties.remove(key);
        if (autoCommit) {
            return saveProperties(comments);
        }
        return true;
    }

    /**
     * 保存Properties
     * @return Boolean
     */
    public Boolean saveProperties() {
        return saveProperties("");
    }

    /**
     * 保存Properties
     * @param comments 說明
     * @return Boolean
     */
    public Boolean saveProperties(String comments) {
        try {
            String path = ClassLoader.getSystemResource(fileName).toURI().getPath();
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(path), charsetName);

            properties.store(outputStreamWriter, comments);
            outputStreamWriter.close();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 打印properties
     */
    public void toList() {

        Enumeration<Object> keys = properties.keys();
        System.out.println("-- listing PropertiesUtils --");

        while (keys.hasMoreElements()) {
            String key = (String) keys.nextElement();
            System.out.println(String.format("%s=%s", key, getProperty(key)));
        }
    }
}

測試：

public class PropertiesReader {

    public static void main(String[] args) {

        String fileName = "chan.properties";
        PropertiesUtils propUtils = new PropertiesUtils(fileName);

        //查詢key->value
        String key = "name";
        String value = propUtils.getProperty(key);
        System.out.printf("%s=%s%n", key, value);
        System.out.println("--------------------------------");

        //獲取map
        Map<String, String> propMap = propUtils.getPropToMap();
        propMap.forEach((k, v) -> System.out.println(String.format("%s=%s", k, v)));
        System.out.println("--------------------------------");

        //更新值
        propUtils.setProperty(key, "習慣");
        System.out.println(propUtils.getProperty(key));
        System.out.println("--------------------------------");

        //新增值
        propUtils.setProperty("hobby.one", "足球");
        propUtils.setProperty("hobby.two", "football");

        //刪除
        propUtils.remove("hobby.two");

        //打印properties
        new PropertiesUtils(fileName).toList();
    }
}

繼承Properties，並重寫部分方法，經測試確實可以實現順序讀寫。
OrderedProperties主要是通過Set保存properties的key，並重寫有關peoperties key的方法，但是目前只是重寫部分方法。
測試過程中發現，remove並保存的時候，出現空指針異常。經排查發現是key的問題，於是在網上找的方法的基礎上，重寫了remove方法。

由於還沒看源碼，可能還會有其他的問題，在這里記錄一下。
但是目前常用操作都有了，也ok.