Properties读取load()，操作，存储store()配置文件简介

2019独角兽企业重金招聘Python工程师标准>>>

http://blog.csdn.net/wjw_java/article/details/7950765

1.   
2. import java.io.BufferedReader;  
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.FileReader;  
7. import java.io.FileWriter;  
8. import java.io.IOException;  
9. import java.util.Iterator;  
10. import java.util.Properties;  
11. import java.util.Set;  
12.   
13. /** 
14.  * Properties是hashtable的子类，也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串 
15.  * Properties是集合和IO相结合的集合容器 
16.  * 该对象的特点可以用于键值对形式的配置开发 
17.  * 那么在加载数据时，需要数据有固定格式，键=值 
18.  *  
19.  * p.load(new FileReader("路径"));//加载配置文件 
20.  * p.stote(new FileWriter("路径"),"");//把修改的信息存储在配置文件中 
21.  *  
22.  *  
23.  * @author wjw 
24.  */  
25. public class Properties_class {  
26.     public static void main(String[] args) {  
27. //      setGetProperties();   
28.         //duQu();   
29.         load_store();  
30. //      load_store1();   
31.     }  
32.     /* 
33.      * Properties类中的load()方法，读取文件到Properties对象中 
34.      * Properties类中的store()方法，将Properties对象中数据存储到文件中 
35.      *  
36.      * 提醒load,store分别都有字符流，字节流的方法的重载. 
37.      */  
38.     public static void load_store(){  
39.         Properties p=new Properties();  
40.         FileReader fr=null;  
41.         FileWriter fw=null;  
42.           
43.         try {  
44.             fr=new FileReader("g:/java/text.txt");  
45.             p.load(fr);//load()方法可通过字符流直接加载文件   
46.             p.setProperty("b","8888888888");  
47.             fw=new FileWriter("g:/java/text.txt");  
48.             p.store(fw,"jack");//将Properties中的信息存储到文件中   
49.             System.out.println(p);  
50.             p.list(System.out);//将信息打印到控制台   
51.         } catch (FileNotFoundException e) {  
52.             e.printStackTrace();  
53.         } catch (IOException e) {  
54.             e.printStackTrace();  
55.         }finally{  
56.             try {  
57.                 if(fr!=null){  
58.                     fr.close();  
59.                 }  
60.             } catch (Exception e2) {  
61.             }  
62.             try {  
63.                 if(fw!=null){  
64.                     fw.close();  
65.                 }  
66.             } catch (Exception e2) {  
67.             }  
68.         }  
69.     }  
70.     public static void load_store1(){  
71.         Properties p=new Properties();  
72.         FileInputStream fis=null;  
73.         FileOutputStream fos=null;  
74.           
75.         try {  
76.             fis=new FileInputStream("g:/java/text.txt");  
77.             p.load(fis);//load()方法可通过字符流直接加载文件   
78.               
79.             //p.remove("lisi");   
80.             p.setProperty("a","11111");  
81.             fos=new FileOutputStream("g:/java/text.txt");  
82.             p.store(fos,"jack");//将Properties中的信息存储到文件中   
83.               
84.             System.out.println(p);  
85.             p.list(System.out);//将信息打印到控制台   
86.         } catch (FileNotFoundException e) {  
87.             e.printStackTrace();  
88.         } catch (IOException e) {  
89.             e.printStackTrace();  
90.         }finally{  
91.             try {  
92.                 if(fis!=null){  
93.                     fis.close();  
94.                 }  
95.             } catch (Exception e2) {  
96.             }  
97.             try {  
98.                 if(fos!=null){  
99.                     fos.close();  
100.                 }  
101.             } catch (Exception e2) {  
102.             }  
103.         }  
104.     }  
105.       
106.     /*  
107.      * 遍历Properties类中的键值对 
108.      */  
109.     public static void bianLi(Properties p){  
110.         Set<String>set=p.stringPropertyNames();  
111.         for(String str:set){  
112.             System.out.println("键："+str+"----值:"+p.getProperty(str));  
113.         }  
114.     }  
115.     /* 
116.      * 读取配置文件中的数据放到Properties集合中，这其实是Properties类中load()方法的原理 
117.      */  
118.     public static void duQu(){  
119.         BufferedReader br=null;  
120.         Properties p=new Properties();  
121.         try {  
122.             br=new BufferedReader(new FileReader("g:/java/text.txt"));  
123.             String str="";  
124.             String[] split=new String[2];  
125.             while(null!=(str=br.readLine())){  
126.                 split=str.split("=");//解析数据   
127.                 p.setProperty(split[0],split[1]);//将数据存储到Properties中   
128.             }  
129.             bianLi(p);//调用遍历Properties类的方法   
130.         } catch (IOException e) {  
131.             e.printStackTrace();  
132.         }finally{  
133.             try {  
134.                 if(null!=br){  
135.                     br.close();  
136.                 }  
137.             } catch (Exception e2) {  
138.                  e2.printStackTrace();  
139.             }  
140.         }  
141.     }  
142.       
143.     /* 
144.      * Properties类中的getProtertity(),setProtertity()方法 
145.      */  
146.     public static void setGetProperties(){  
147.         Properties p=new Properties();  
148.         p.setProperty("zhangsan", "33");//设定Properties类中存放的键值对   
149.         p.setProperty("lisi", "22");  
150.         p.setProperty("wangwu", "3563");  
151.         p.setProperty("zhaoliu", "3663");  
152.           
153.         p.setProperty("lisi","9999");//修改lisi的值，原来的值会被覆盖掉   
154.         System.out.println(p);//直接打印集合可获取集合信息   
155.           
156.         String zhi=p.getProperty("lisi");//根据键获取值   
157.         System.out.println(zhi);  
158.         //用原始方法遍历Properties集合   
159.         Set<Object> set=p.keySet();  
160.         Iterator<Object> iter=set.iterator();  
161.         while(iter.hasNext()){  
162.             String str=(String)iter.next();  
163.             System.out.println(str+":"+p.getProperty(str));  
164.         }  
165.         System.out.println("---------------------------------------------");  
166.         //用Properties类中定义的方法遍历集合：   
167.         Set<String>set_str=p.stringPropertyNames();  
168.         for(String str_a:set_str){  
169.             System.out.println(str_a+":"+p.getProperty(str_a));  
170.         }  
171.     }  
172. }  

package com.io;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

/**
 * Properties是hashtable的子类，也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串
 * Properties是集合和IO相结合的集合容器
 * 该对象的特点可以用于键值对形式的配置开发
 * 那么在加载数据时，需要数据有固定格式，键=值
 * 
 * p.load(new FileReader("路径"));//加载配置文件
 * p.stote(new FileWriter("路径"),"");//把修改的信息存储在配置文件中
 * 
 * 
 * @author wjw
 */
public class Properties_class {
	public static void main(String[] args) {
//		setGetProperties();
		//duQu();
		load_store();
//		load_store1();
	}
	/*
	 * Properties类中的load()方法，读取文件到Properties对象中
	 * Properties类中的store()方法，将Properties对象中数据存储到文件中
	 * 
	 * 提醒load,store分别都有字符流，字节流的方法的重载.
	 */
	public static void load_store(){
		Properties p=new Properties();
		FileReader fr=null;
		FileWriter fw=null;
		
		try {
			fr=new FileReader("g:/java/text.txt");
			p.load(fr);//load()方法可通过字符流直接加载文件
			p.setProperty("b","8888888888");
			fw=new FileWriter("g:/java/text.txt");
			p.store(fw,"jack");//将Properties中的信息存储到文件中
			System.out.println(p);
			p.list(System.out);//将信息打印到控制台
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fr!=null){
					fr.close();
				}
			} catch (Exception e2) {
			}
			try {
				if(fw!=null){
					fw.close();
				}
			} catch (Exception e2) {
			}
		}
	}
	public static void load_store1(){
		Properties p=new Properties();
		FileInputStream fis=null;
		FileOutputStream fos=null;
		
		try {
			fis=new FileInputStream("g:/java/text.txt");
			p.load(fis);//load()方法可通过字符流直接加载文件
			
			//p.remove("lisi");
			p.setProperty("a","11111");
			fos=new FileOutputStream("g:/java/text.txt");
			p.store(fos,"jack");//将Properties中的信息存储到文件中
			
			System.out.println(p);
			p.list(System.out);//将信息打印到控制台
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fis!=null){
					fis.close();
				}
			} catch (Exception e2) {
			}
			try {
				if(fos!=null){
					fos.close();
				}
			} catch (Exception e2) {
			}
		}
	}
	
	/* 
	 * 遍历Properties类中的键值对
	 */
	public static void bianLi(Properties p){
		Set<String>set=p.stringPropertyNames();
		for(String str:set){
			System.out.println("键："+str+"----值:"+p.getProperty(str));
		}
	}
	/*
	 * 读取配置文件中的数据放到Properties集合中，这其实是Properties类中load()方法的原理
	 */
	public static void duQu(){
		BufferedReader br=null;
		Properties p=new Properties();
		try {
			br=new BufferedReader(new FileReader("g:/java/text.txt"));
			String str="";
			String[] split=new String[2];
			while(null!=(str=br.readLine())){
				split=str.split("=");//解析数据
				p.setProperty(split[0],split[1]);//将数据存储到Properties中
			}
			bianLi(p);//调用遍历Properties类的方法
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(null!=br){
					br.close();
				}
			} catch (Exception e2) {
				 e2.printStackTrace();
			}
		}
	}
	
	/*
	 * Properties类中的getProtertity(),setProtertity()方法
	 */
	public static void setGetProperties(){
		Properties p=new Properties();
		p.setProperty("zhangsan", "33");//设定Properties类中存放的键值对
		p.setProperty("lisi", "22");
		p.setProperty("wangwu", "3563");
		p.setProperty("zhaoliu", "3663");
		
		p.setProperty("lisi","9999");//修改lisi的值，原来的值会被覆盖掉
		System.out.println(p);//直接打印集合可获取集合信息
		
		String zhi=p.getProperty("lisi");//根据键获取值
		System.out.println(zhi);
		//用原始方法遍历Properties集合
		Set<Object> set=p.keySet();
		Iterator<Object> iter=set.iterator();
		while(iter.hasNext()){
			String str=(String)iter.next();
			System.out.println(str+":"+p.getProperty(str));
		}
		System.out.println("---------------------------------------------");
		//用Properties类中定义的方法遍历集合：
		Set<String>set_str=p.stringPropertyNames();
		for(String str_a:set_str){
			System.out.println(str_a+":"+p.getProperty(str_a));
		}
	}
}

 

转载于:https://my.oschina.net/u/347386/blog/118036