前段时间自己写了一个用来读写配置文件的类，并写上了完整的注释，下面是源代码。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;


/**
 *本类是用来读取和写入配置文件的
 *再操作过程中只需要只用配置文件的名字
 *配置文件统一使用小写并以 <SUFFIX> 为后缀
 *配置文件的路径为 <PATH>
 *-------------------------------------
 *使用要求：
 *	在配置文件路径中，必须有一个被命名为 <INITIALIZATION> 的初始化配置文件。
 *名为<INITIALIZATION>的配置文件的推荐内容（可修改）：
 	ignore= 
	verson=0.01
	writer_isContinue=true
 *以上几个参数分别为ignore：自动忽略的读取内容
 *				   verson：版本号
 *				   writer_isContinue：写入配置文件的时候默认是否在原基础上续写。
 *-------------------------------------
 * @author Administrator fordring
 *
 */
public class configer {
	private static final String INITIALIZATION = "initialization"; //初始化配置文件的文件名
	private static final String SUFFIX = ".cnm";//所有配置文件的后缀名
	private static final String PATH ="./parts/config/";//配置文件的路径
	private boolean writer_isContinue = true;//是否在原文件上继续写入（true是不覆盖原文件写入，false是清除原文件再覆盖式写入）
	private String file;//默认的配置文件名
	private String ignore ;//读取时无视某一个字符，如无视空格
	private String regex = "=";//读取时的分隔符,默认为"=".
	private BufferedReader reader;//读取流
	private BufferedWriter writer;//写入流
	private HashMap<String,String> map;//读取的结果
	public final String verson;//版本号
	private Date date;//系统时间
	/**
	 * 在构造器中传入配置文件名可以更方便的使用该类的方法
	 * @param file 配置文件名
	 */
	public configer(String file) {
		System.out.println("-------------开始构造configer--------------------------------------");
		this.file = file;//设置默认配置文件
		date = new Date(System.currentTimeMillis());//获得系统时间
		System.out.println(date);
		write("history",date.toString());//写入历史
		map = new HashMap<String,String>();//初始化map
		map = read(INITIALIZATION);//读取初始设置
		verson =map.get("verson");//初始化版本号
		ignore = map.get("ignore");//初始化忽略符
		writer_isContinue = Boolean.valueOf(map.get("writer_isContinue"));//初始化writer_isContinue
		System.out.println("-------------configer构造完毕--------------------------------------");
	}
	/**
	 * 不设置默认配置文件式构造configer
	 */
	public configer(){
		this(null);
	}
	/**
	 * 读取配置文件
	 * 输入配置文件名（不需要加后缀）
	 * @param file 配置文件名
	 * @return 
	 */
	public HashMap<String,String> read(String file) {
		System.out.println("----正在读取配置文件----");
		try {
			reader = new BufferedReader(new FileReader(PATH+file+SUFFIX));
			System.out.println("读取初始化完成");
			String buffer;
			String[] group;
			System.out.println("开始读取");
			while((buffer = reader.readLine()) != null){
				if(ignore!=null)buffer = ignore(buffer);
				group = buffer.split(regex);
				map.put(group[0], group[1]);
			}
			System.out.println("----读取成功----");
			System.out.println(map);
			return map;
		} catch (FileNotFoundException e) {
			System.out.println("读取配置文件失败：找不到该文件");
			throwException("读取配置文件失败：找不到该文件\n"+e);
		} catch (IOException e) {
			System.out.println("读取配置文件失败：读取时出错");
			throwException("读取配置文件失败：读取时出错\n"+e);
		} catch (Exception e){
			System.out.println("错误");
			throwException("读取配置文件失败：找不到该文件\n"+e);
		}
		System.out.println("----读取失败-----");
		System.out.println(map);
		return map;
	}
	public HashMap<String,String> read(){
		if(this.file == null)return null;
		return read(file.toString());
	}
	/**
	 * 向指定配置文件写入指定字符行
	 * 默认不覆盖原文件（在原有基础上写入）
	 * @param file 配置文件名
	 * @param str 输入的字符串
	 * @param isContinue 是否在原文件上继续写入（true是不覆盖原文件写入，false是清除原文件再覆盖式写入）
	 */
	public void write(String file,String str,boolean isContinue){
		System.out.println("---------开始向配置文件 "+file+" 中写入文字，是否续写："+isContinue);
		try {
			writer  = new BufferedWriter(new FileWriter(PATH+file+SUFFIX,isContinue));
			writer.write(str);
			writer.newLine();  
			System.out.println("写入成功");
		} catch (IOException e) {
			System.out.println("文件写入失败");
			throwException("文件写入失败\n"+e);
		}catch (Exception e){
			System.out.println("错误!");
			throwException("输出配置文件失败\n"+e);
		}finally{  
            try {
            	writer.flush();  
				writer.close();
			} catch (IOException e) {
				System.out.println("关闭输出流失败");
				throwException("输出流关闭失败\n"+e);
			}  
        }  
	}
	/**
	 * 向默认配置文件中输出str
	 * @param str 输出内容
	 * @param isContinue 是否在原文件上继续写入（true是不覆盖原文件写入，false是清除原文件再覆盖式写入）
	 */
	public void write(String str,boolean isContinue){
		write(file.toString(),str,isContinue);
	}
	/**
	 * 向默认配置文件中输出str
	 * @param file 配置文件名
	 * @param str 输出内容
	 */
	public void write(String file,String str){
		write(file,str,writer_isContinue);
	}
	/**
	 * 向默认配置文件中输出str
	 * @param str 输出内容
	 */
	public void write(String str){
		write(str,writer_isContinue);
	}
	/**
	 * 向一个配置文件中输出一个map
	 * @param map 输出的map
	 * @param file 目标配置文件名
	 * @param isContinue 是否在原文件上继续写入（true是不覆盖原文件写入，false是清除原文件再覆盖式写入）
	 */
	public void writein(HashMap map,String file,boolean isContinue){
		System.out.println("--------正在输出map至"+file+"--------");
		try{
			if(!isContinue)clear(file);
			System.out.println(""+map+"——>"+file);
			Iterator iter = map.entrySet().iterator();//获得map的迭代器
			while(iter.hasNext()){
				Entry e =(Entry)iter.next();
				write(file,(String)e.getKey()+"="+(String)e.getValue());
			}
		}catch (Exception e) {
			System.out.println("输出map至"+file+"失败！原因未知");
			util.exc("输出map至"+file+"失败！原因未知"+e);
		}
	}
	/**
	 * 清空某一个配置文件
	 * @param file配置文件名
	 */
	public void clear(String file){
		try {
			writer  = new BufferedWriter(new FileWriter(PATH+file+SUFFIX));
			System.out.println("已清空"+file);
		} catch (IOException e) {
			System.out.println(file+"清空失败");
			throwException(file+"清空失败\n"+e);
		}finally{  
            try {
            	writer.flush();  
				writer.close();
			} catch (IOException e) {
				System.out.println("关闭输出流失败");
				throwException("关闭输出流失败\n"+e);
			}catch (Exception e){
				System.out.println("清空配置文件时出错!");
				throwException("清空配置文件时出错!\n"+e);
			}
		}
	}
	/**
	 * 清除默认的file
	 */
	public void clear(){
		if(this.file == null)return;
		clear(file.toString());
	}
	/**
	 * 将writer载入某个配置文件
	 * @param file配置文件名
	 */
	private void loadin(String file){
		try {
			writer  = new BufferedWriter(new FileWriter(PATH+file+SUFFIX,true));
			System.out.println("已载入writer为"+file);
		} catch (IOException e) {
			System.out.println("错误：载入writer失败");
		}
	}
	/**
	 * 将writer载入默认的file
	 */
	private void loadin(){
		if(this.file == null)return;
		loadin(file.toString());
	}
	/**
	 * 向exception.cnm导出异常情况
	 * @param e异常内容
	 */
	private void throwException(String e){
		try {
			System.out.println("--正在导出异常--");
			loadin("exception");
			writer.write("--------------");
			writer.newLine();
			writer.write(date.toString());
			writer.newLine();
			writer.write(e);
			writer.newLine();
			writer.write("--------------");
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}finally{  
            try {
            	writer.flush();  
				writer.close();
				System.out.println("--成功导出异常--");
			} catch (IOException e1) {
				System.out.println("关闭输出流失败");
			}  
        }  
		
	}
	/**
	 * 取出一个字符串中，与ignore相同的字符串
	 * @param str待处理字符串
	 * @return 处理后的结果
	 */
	private String ignore(String str){
		try {
			str = str.replace(ignore, "");
			System.out.println("替换成功");
		} catch (Exception e) {
			System.out.println("替换失败");
		}
		return str;
	}
	

	
	/**
	 * @return 获得默认的writer是否在原文件上写入
	 */
	public boolean isWriter_isContinue() {
		return writer_isContinue;
	}
	/**
	 * 设置writer的默认的是否在原文件上写入
	 * @param writer_isContinue
	 */
	public void setWriter_isContinue(boolean writer_isContinue) {
		this.writer_isContinue = writer_isContinue;
	}
	/**
	 * @return 返回默认目标配置文件
	 */
	public String getFile() {
		return file;
	}
	/**
	 * 设置默认目标配置文件
	 * @param file
	 */
	public void setFile(String file) {
		this.file = file;
	}
	/**
	 * @return 返回忽视的字符串
	 */
	public String getIgnore() {
		return ignore;
	}
	/**
	 * 设置忽视的字符串
	 * @param ignore
	 */
	public void setIgnore(String ignore) {
		this.ignore = ignore;
	}
	/**
	 * @return 获得分隔符
	 */
	public String getRegex() {
		return regex;
	}
	/**
	 * 设置分隔符
	 * @param regex
	 */
	public void setRegex(String regex) {
		this.regex = regex;
	}
	/**
	 * @return 获得版本号
	 */
	public String getVerson() {
		return verson;
	}
	/**
	 * toString返回map的内容
	 */
	public String toString(){
		return map.toString();
	}
	/**
	 * 打印出该实例全部的数据
	 */
	public void printData(){
		System.out.println("--------------------现在打印全部数据-----------------------");
		System.out.println("默认的配置文件—> "+file);
		System.out.println("系统时间 —> "+date);
		System.out.println("分隔符 —> "+regex);
		Iterator iter = map.entrySet().iterator();//获得map的迭代器
		while(iter.hasNext()){
			Entry e =(Entry)iter.next();
			System.out.println(e.getKey()+"—> "+e.getValue());
		}
		System.out.println("--------------------打印全部数据完毕-----------------------");
	}
}