Java config.properties参数配置扩展

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
 * 扩展properties工具类
 * 
 * @author yuxi
 * @date 2020-5-19
 */
public class SafeProperties {
   

	/**
	 * 内部属性表
	 */
	private final Properties props;

	/**
	 * 保存key与comment的映射， 同时利用这个映射来保证key的顺序。
	 */
	private final LinkedHashMap<String, String> keyCommentMap = new LinkedHashMap<String, String>();

	private static final String BLANK = "";

	public SafeProperties() {
   
		super();
		props = new Properties();
	}

	public SafeProperties(Properties defaults) {
   
		super();
		props = new Properties(defaults);
	}

	/**
	 * 设置一个属性，如果key已经存在，那么将其对应value值覆盖。
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public String setProperty(String key, String value) {
   
		return setProperty(key, value, BLANK);
	}

	/**
	 * 设置一个属性，如果key已经存在，那么将其对应value值覆盖。
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            与键对应的值
	 * @param comment
	 *            对键值对的说明
	 * @return
	 */
	public synchronized String setProperty(String key, String value, String comment) {
   
		Object oldValue = props.setProperty(key, value);
		if (BLANK.equals(comment)) {
   
			if (!keyCommentMap.containsKey(key)) {
   
				keyCommentMap.put(key, comment);
			}
		} else {
   
			keyCommentMap.put(key, comment);
		}
		return (String) oldValue;
	}

	/**
	 * 根据key获取属性表中相应的value。
	 * 
	 * @param key
	 * @return
	 */
	public String getProperty(String key) {
   
		return props.getProperty(key);
	}

	/**
	 * 根据key获取属性表中相应的value。 如果没找到相应的value，返回defaultValue。
	 * 
	 * @param key
	 * @param defaultValue
	 * @return
	 */
	public String getProperty(String key, String defaultValue) {
   
		return props.getProperty(key, defaultValue);
	}

	/**
	 * 从一个字符流中读取属性到属性表中
	 * 
	 * @param reader
	 * @throws IOException
	 */
	public synchronized void load(Reader reader) throws IOException {
   
		load0(new LineReader(reader));
	}

	/**
	 * 从一个字节流中读取属性到属性表中
	 * 
	 * @param inStream
	 * @throws IOException
	 */
	public synchronized void load(InputStream inStream) throws IOException {
   
		load0(new LineReader(inStream));
	}

	/**
	 * 从一个字节流中读取属性到属性表中
	 * 
	 * @param inStream
	 * @param charset
	 * @throws IOException
	 */
	public synchronized void load(InputStream inStream, String charset) throws IOException {
   
		InputStreamReader reader = new InputStreamReader(inStream, charset);
		load0(new LineReader(reader));
	}

	/**
	 * 从一个文件中读取属性到属性表中
	 * 
	 * @param file
	 *            属性文件
	 * @param charset
	 *            字符集
	 * @throws IOException
	 */
	public synchronized void load(File file, String charset) throws IOException {
   
		FileInputStream inputStream = new FileInputStream(file);
		InputStreamReader reader = new InputStreamReader(inputStream, charset);
		load0(new LineReader(reader));
	}

	/**
	 * 从一个文件中读取属性到属性表中 默认字符集为utf-8
	 * 
	 * @param file
	 *            属性文件
	 * @throws IOException
	 */
	public synchronized void load(File file) throws IOException {
   
		FileInputStream inputStream = new FileInputStream(file);
		InputStreamReader reader = new InputStreamReader(inputStream, "utf-8");
		load0(new LineReader(reader));
	}

	/**
	 * 将属性表中的属性写到字符流里面。
	 * 
	 * @param writer
	 * @throws IOException
	 */
	public void store(Writer writer) throws IOException {
   
		store0((writer instanceof BufferedWriter) ? (BufferedWriter) writer : new BufferedWriter(writer), false);
	}

	/**
	 * 将属性表中的属性写到字节流里面。
	 * 
	 * @param out
	 * @throws IOException
	 */
	public void store(OutputStream out) throws IOException {
   
		store0(new BufferedWriter(new OutputStreamWriter(out, "utf-8")), true);
	}

	/**
	 * 如果属性表中某个key对应的value值和参数value相同 那么返回true，否则返回false。
	 * 
	 * @param value
	 * @return
	 */
	public boolean containsValue(String value) {
   
		return props.containsValue(value);
	}

	/**
	 * 如果属性表中存在参数key，返回true，否则返回false。
	 * 
	 * @param key
	 * @return
	 */
	public boolean containsKey(String key) {
   
		return props.containsKey(key);
	}

	/**
	 * 获取属性表中键值对数量
	 * 
	 * @return
	 */
	public int size() {
   
		return props.