java Properties类学习笔记
java中properties配置文件的用法
java中properties配置文件的用法Java中Properties配置文件的用法:一、什么是Properties配置文件1、Properties配置文件是一种常用的Java文件配置格式,其特点是配置文件可以以“Key-Value”的方式存储数据;2、配置文件格式为“.properties”,与XML文件、JSON文件等格式不同,Properties配置文件则是一种更为简单的文件格式;3、此外,Properties是一种针对字符串的文件格式,在配置文件中可以通过类似于“key1=value1”的格式来存储字符串。
二、优点1、Properties配置文件具有易操作性和易读性,其格式为“key=value”,容易阅读理解;2、Properties配置文件具有可定制化性,配置文件在被加载时会自动检测文件类型;3、Properties具有可读性,在一定程度上使得代码的可读性更强;4、Properties配置文件可以被多语言所支持,且保持可读性;5、当我们使用Properties配置文件对数据进行加载时,可以根据特定键来获取特定的值,从而简化获取数据的操作。
三、使用Properties配置文件的方式1、直接获取Properties配置文件:使用getResourceAsStream()方法可以直接获取Properties文件中的内容;2、使用Properties类:可以使用Properties类将Properties文件字节流传输到Properties类,从而获取Properties类对象,并从Properties对象获取配置文件中的信息;3、使用Spring进行加载:可以使用Spring的<context:property-placeholder>标签将Properties文件的内容加载到Spring容器中,从而实现自动加载配置文件中的内容,也可以使用Spring自带的PropertyPlaceholderConfigurer来获取配置文件中的内容。
给你的JAVA程序配置参数(Properties的使用)
给你的JAVA程序配置参数(Properties的使⽤)我们在写JAVA程序时,很多时候运⾏程序的参数是需要动态改变的测试时⼀系列参数,运⾏时⼀系列参数⼜或者数据库地址也需要配⼀套参数,以⽅便今后的动态部署这些变量的初始化,我们在写⼩DEMO时完全可以写死在JAVA⽂件中但程序需要发布或者局部部署时,这些参数就需要脱离程序代码了我们有多种存放参数的⽅式,⽐如数据库、XML⽂件⼜或者直接是txt⽂件现在介绍⼀种使⽤JAVA,简单⽅便的参数读取⽅式.properties⽂件,我们并不陌⽣,很多优秀的框架中就能看到它的存在,⽐如Hibernate在src⽂件⽬录下,新建⼀个后缀为.properties的⽂件,⽤任意⽂本编辑器打开它,就可以使⽤键值对的⽅式设置您程序的运⾏参数了类似于这样#wangqun fd60e46db0dc119cfea740c3375fd7c4#toAccountId=fd60e46db0dc119cfea740c3375fd7c4#huangshi 1645a78135328c4btoAccountId=1645a78135328c4b#tangwei 6c0f7514f4bd0016#shixiaoping 98f30bad9e6789af#toAccountId=6c0f7514f4bd0016#toAccountId=6c0f7514f4bd0016,1645a78135328c4b,98f30bad9e6789af#cron=0 32 8-11,14-20/1 * * ?cron=0/10 * * * * ?fileName=d\:/\u59DC\u5830\u5468\u79EF\u5206\u7BA1\u63A7\u53CA\u53CC\u767E\u5146\u8BAD\u7EC3\u84250830.xlsxsheetName=\u6C47\u603BfromIndex=0,1toIndex=48,12#fromIndex=1,4#toIndex=13,12dirPath=C:/apache-tomcat-8.0.28/webapps/test/urlPath=http://61.132.43.176:8081/test/database_host=132.240.9.36database_port=1521database_user=jydatabase_name=yxdbdatabase_pwd=OVQwu8QSm4CWktEZdnjtxg==sql_str=select * from hs_bb_rbb r order by r.nomodify_sheet=sheet1modify_from=1,0time_cell=1,4注意⼀下⼏点:⼀、⽤#号表⽰注释,可以多录⼊⼀些配置可能,运⾏时动态注释或者打开,⽐较⽅便⼆、.properties明⽂存储,所以敏感字符需要加密,⽐如数据的密码三、遇到中⽂,是个棘⼿的问题,最简单的⽅式是使⽤MyEclipse的properties⽂件编辑器来写⼊,会⾃动将中⽂转码四、所有参数只可以以字符串形式存储,⾄于类型转换,请在JAVA中解析完成五、适⽤于只读不写的参数配置,如果程序运⾏过程中需要修改这些环境参数,建议考虑数据库读写⽅式,⽽不是properties下⾯是JAVA程序,mian函数⼀开始就可以对这个properties⽂件进⾏读取public static void main(String[] args) throws Exception{//读取properties配置⽂件Properties prop=new Properties();prop.load(QuartzDemo.class.getResourceAsStream("/set.properties"));String cron=prop.getProperty("cron","0/10 * 8-7 * * ?");String fileName=prop.getProperty("fileName","d:/2014年1⽉营销活动报表140116.xlsx");String sheetName=prop.getProperty("sheetName", "⽀局视图");String dirPath=prop.getProperty("dirPath","C:/apache-tomcat-8.0.28/webapps/test/");String urlPath=prop.getProperty("urlPath","http://61.132.43.176:8081/test/");String fromIndexStr=prop.getProperty("fromIndex","0,0");String toIndexStr=prop.getProperty("toIndex", "17,20");String database_host=prop.getProperty("database_host","");String database_port=prop.getProperty("database_port","");String database_user=prop.getProperty("database_user","");String database_name=prop.getProperty("database_name","");String database_pwd=DESHelper.decrypt(prop.getProperty("database_pwd",""),"newflypig");String sql_str=prop.getProperty("sql_str","");String modify_sheet=prop.getProperty("modify_sheet","");String modify_fromStr=prop.getProperty("modify_from","0,0");String[] splitStr=fromIndexStr.split(",");int[] fromIndex={Integer.parseInt(splitStr[0]),Integer.parseInt(splitStr[1])};splitStr=toIndexStr.split(",");int[] toIndex={Integer.parseInt(splitStr[0]),Integer.parseInt(splitStr[1])};splitStr=modify_fromStr.split(",");int[] modify_from={Integer.parseInt(splitStr[0]),Integer.parseInt(splitStr[1])};}Properties类提供了⾮常便捷的读取properties⽂件的操作,还包括⼀些默认值的配置,再次需要注意的是,只能读String,如果遇到其他数据类型,聪明的你⼀定知道怎样⽤String类型转换这些类型吧。
Properties类的使用序列化与反序列化
Properties类的使⽤序列化与反序列化Properties 类表⽰了⼀个持久的属性集。
Properties 可保存在流中或从流中加载。
属性列表中每个键及其对应值都是⼀个字符串。
特点: 1、Hashtable的⼦类,map集合中的⽅法都可以⽤。
2、该集合没有泛型。
键值都是字符串。
3、它是⼀个可以持久化的属性集。
键值可以存储到集合中,也可以存储到持久化的设备(硬盘、U盘、光盘)上。
键值的来源也可以是持久化的设备。
4、有和流技术相结合的⽅法。
⽅法: load(InputStream) 把指定流所对应的⽂件中的数据,读取出来,保存到Propertie集合中 load(Reader) store(OutputStream,commonts)把集合中的数据,保存到指定的流所对应的⽂件中,参数commonts代表对描述信息 stroe(Writer,comments); 代码演⽰:/*** Properties集合,它是唯⼀⼀个能与IO流交互的集合** 需求:向Properties集合中添加元素,并遍历** ⽅法:* public Object setProperty(String key, String value)调⽤ Hashtable 的⽅法 put。
* public Set<String> stringPropertyNames()返回此属性列表中的键集,* public String getProperty(String key)⽤指定的键在此属性列表中搜索属性*/public class PropertiesDemo01 {public static void main(String[] args) {//创建集合对象Properties prop = new Properties();//添加元素到集合//prop.put(key, value);prop.setProperty("周迅", "张学友");prop.setProperty("李⼩璐", "贾乃亮");prop.setProperty("杨幂", "刘恺威");//System.out.println(prop);//测试的使⽤//遍历集合Set<String> keys = prop.stringPropertyNames();for (String key : keys) {//通过键找值//prop.get(key)String value = prop.getProperty(key);System.out.println(key+"==" +value);}}} 读取⽂件中的数据,并保存到集合:public class PropertiesDemo03 {public static void main(String[] args) throws IOException {//1,创建集合Properties prop = new Properties();//2,创建流对象FileInputStream in = new FileInputStream("prop.properties");//FileReader in = new FileReader("prop.properties");//3,把流所对应⽂件中的数据读取到集合中prop.load(in);//4,关闭流in.close();//5,显⽰集合中的数据System.out.println(prop);}}注意:使⽤字符流FileReader就可以完成⽂件中的中⽂读取操作了ObjectOutputStream对象序列化流 ObjectOutputStream 将 Java 对象的基本数据类型和图形写⼊ OutputStream。
Properties类操作.properties配置文件方法总结
Properties类操作.properties配置⽂件⽅法总结⼀、properties⽂件Properties⽂件是java中很常⽤的⼀种配置⽂件,⽂件后缀为“.properties”,属⽂本⽂件,⽂件的内容格式是“键=值”的格式,可以⽤“#”作为注释,java编程中⽤到的地⽅很多,运⽤配置⽂件,可以便于java深层次的解耦。
例如java应⽤通过JDBC连接数据库时,可以把数据库的配置写在配置⽂件 jdbc.properties:driver=com.mysql.jdbc.DriverjdbcUrl=jdbc:mysql://localhost:3306/useruser=rootpassword=123456这样我们就可以通过加载properties配置⽂件来连接数据库,达到深层次的解耦⽬的,如果想要换成oracle或是DB2,我们只需要修改配置⽂件即可,不⽤修改任何代码就可以更换数据库。
⼆、Properties类java中提供了配置⽂件的操作类Properties类(java.util.Properties):读取properties⽂件的通⽤⽅法:根据键得到value/*** 读取config.properties⽂件中的内容,放到Properties类中* @param filePath ⽂件路径* @param key 配置⽂件中的key* @return返回key对应的value*/public static String readConfigFiles(String filePath,String key) {Properties prop = new Properties();try{InputStream inputStream = new FileInputStream(filePath);prop.load(inputStream);inputStream.close();return prop.getProperty(key);}catch (Exception e) {e.printStackTrace();System.out.println("未找到相关配置⽂件");return null;}}把配置⽂件以键值对的形式存放到Map中:/*** 把.properties⽂件中的键值对存放在Map中* @param inputStream 配置⽂件(inputstream形式传⼊)* @return返回Map*/public Map<String, String> convertPropertityFileToMap(InputStream inputStream) {try {Properties prop = new Properties();Map<String, String> map = new HashMap<String, String>();if (inputStream != null) {prop.load(inputStream);Enumeration keyNames = prop.propertyNames();while (keyNames.hasMoreElements()) {String key = (String) keyNames.nextElement();String value = prop.getProperty(key);map.put(key, value);}return map;} else {return null;}} catch (Exception e) {e.printStackTrace();return null;}}。
Java中Properties类的使用
import java.util.Properties;
public class Test {
public static void main(String[] args) {
File pFile = new File("e:\\test.xml"); // properties文件放在e盘下(windows)
p.storeToXML(fW,"test");
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Enumeration enu = p.propertyNames(); //取出所有的key
//输出--1
p.list(System.out) ; //System.out可以改为其他的输出流(包括可以输出到文件)
//输出--2
while( enu .hasMoreElements())
}
Properties p = new Properties();
try {
p .load(pInStream ); //Properties 对象已生成,包括文件中的数据
} catch (IOException e) {
e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.
test.properties文件如下:
#测试环境配置:平台路径配置
jstrd_home=D:/TMS2006/webapp/tms2006/WEB-INF/
properties用法
properties用法
Properties 是 Java 中的一个类,主要用来管理键值对的配置信息。
在 Java 中,Properties 类被广泛用于读取和保存配置文件,或者传递应用程序中的一些参数。
下面我们来介绍一下 Properties 类的用法。
首先,我们需要创建一个 Properties 对象,然后通过其方法来操作配置信息。
在创建 Properties 对象之后,我们可以通过 load() 方法来从文件中读取配置信息,
也可以通过 setProperty() 方法来设置键值对。
接下来,我们可以通过 getProperty() 方法来获取指定键对应的值,也可以通过 list() 方法来打印配置信息。
另外,Properties 类还提供了 store() 方法,可以将配置信息保存到文件中。
这
样可以方便地将配置信息持久化,以便下次使用。
另外,Properties 类还提供了一
些方便的方法,比如 getProperty() 可以指定默认值,也可以通过 getPropertyNames() 方法来获取所有的键值对。
总的来说,Properties 类是 Java 中用来管理配置信息的一个重要工具类。
通过Properties 类,我们可以方便地读取、设置、保存配置信息,从而提高程序的灵活
性和可维护性。
希望以上内容对您有所帮助,如果您有任何疑问,欢迎随时与我交流。
谢谢!。
Java中的Properties集合
Java中的Properties集合Java中的Properties集合1.Properties集合的特点:(1)该集合的键和值都是字符串类型的;(2)集合中的数据可以保存到流中,或者从流中获取;2.通常该集合⽤于操作以键值对形式存在的配置⽂件。
3.配置⽂件:就是存储配置信息的⽂件。
XML⽂件、数据库4.构造⽅法:5.常⽤⽅法:(1)存储元素:setProperty(2)修改元素:setProperty键相同,值不同即是修改。
(3)取出元素:getProperty(4)list⽅法:主要⽤于调试。
参数是PrintStream ,默认的输出设备。
如参数为System.out例如:public static void main(String[] args) {//下午9:15:01Properties pro = new Properties();pro = System.getProperties();pro.list(System.out);}(5)System.getProperties()返回系统的所有的配置信息,返回类型为Properties集合,在调⽤list⽅法就可打印到控制台(System.out)上。
(6)存储⽅法store⽅法:持久化,将集合中的字符串键值信息持久化存储到⽂件中,因此需要关联输出流。
字节输出流或者字符输出流。
Properties p = new Properties();p.setProperty("aaa","111");p.setProperty("aaa2","1112");p.setProperty("aaa3","1113");p.setProperty("aaa4","1114");p.setProperty("aaa5","11165");FileOutputStream fos = new FileOutputStream("e:\\info.txt");//字节输出流FileWriter fw = new FileWriter("e:\\info2.txt");//字符输出流p.store(fos,"info");p.store(fw,"info2");fos.close();fw.close();(7)l oad⽅法:将流中的信息存储到Properties集合中。
JavaProperties工具类详解
JavaProperties⼯具类详解1、Java Properties⼯具类位于java.util.Properties,该⼯具类的使⽤极其简单⽅便。
⾸先该类是继承⾃Hashtable<Object,Object>这就奠定了Properties类的本质其实是⼀个HashTable,那么对于各种⼯具类的典型特性就是在HashTable的基础之上做各种封装,以降低操作的难度。
说⽩了,本质上还是key = value结构,只不过key和value都是字符串⽽已。
可以理解成为⼀个简化版的Map<String, String>。
2、Properties的⽤途,显⽽易见,我们在开发过程中很多地⽅都会⽤到以.properties结尾的配置⽂件,key=valu结构的数据,他没有XML⽂件那么丰富强⼤,但是他简单,我们也不是任何地⽅都需要⽤XML来描述⽐较复杂的嵌套结构。
据我所知,有不少框架在解析.properties⽂件的时候就采⽤的是Properties类或者是基于Properties来扩展,就像Properties扩展HashTable道理差不多。
3、Properties类的使⽤ 1.创建Properties对象,源码中提供2中构造⽅法。
但是本质是⼀致的,在此介绍默认构造⽅法:Properties prop = new Properties(); 2.该类总共⼤概⼆三⼗个⽅法,没有静态⽅法。
所有的⽅法都是针对该类的实例化对象的操作。
按照⼀般的⼯具类的思路,内部虽然有⼆三⼗个⽅法,其实很多都是类似的⽅法,只不过是不⼀样的参数进⾏重载⽽已。
去掉类似的⽅法和重载的⽅法,也就剩下不到10个,⽽这不到10个的⽅法⽤法和特点和Map⼏乎是⼀模⼀样,本⾝他也是继承⾃HashTable的。
3.从.properties⽂件中加载,我们⼀般都是从⽂件中加载属性。
⽽该类提供了3个从⽂件中加载的⽅法,分别是:load(Reader reader)load(InputStream inStream)loadFromXML(InputStream in) 4.对属性的操作 通过上⾯第3步就会使得prop对象拥有了0个或者多个key=value⽅式的属性。
properties基础用法
properties基础用法Properties是Java编程语言中的一个关键字,用于描述类或对象的特性或属性。
在Java中,通过创建属性可以使对象具有更多的状态和行为,从而增强程序的灵活性和可扩展性。
本文将简要介绍Properties的基本用法,并逐步回答有关Properties的问题。
Properties的基本概念Properties是Java中的一个类,它继承自Hashtable类,因此也是一个键值对的集合。
不同之处在于,Properties的键和值都是字符串类型。
在Java中,可以使用Properties来读取和写入配置文件,存储一些设置和信息,以便在程序运行时进行访问和修改。
通常情况下,配置文件的后缀名是.properties,其格式为键值对的形式。
Properties的创建与初始化Properties类提供了多种构造方法来创建对象。
例如,可以使用无参构造方法来创建一个空的Properties对象,并使用setProperty()方法来添加键值对。
Properties properties = new Properties();properties.setProperty("age", "25");Properties的读取与写入通过加载配置文件,可以将其内容读取到Properties对象中,以便在程序中进行访问。
可以使用load()方法来加载配置文件。
FileInputStream fis = new FileInputStream("config.properties"); Properties properties = new Properties();properties.load(fis);fis.close();在加载配置文件后,就可以使用getProperty()方法来读取配置文件中的值。
String name = properties.getProperty("name");String age = properties.getProperty("age");同样,当需要将数据写入配置文件时,可以使用store()方法。
properties文件java用法
【主题】properties文件java用法介绍在Java开发中,properties文件是一种常见的配置文件格式,它通常用来存储键值对的配置信息。
在本文中,我将深入探讨properties文件在Java中的用法,包括读取、写入、使用和常见问题的解决方法。
通过本文的学习,你将能够全面了解properties文件在Java开发中的重要性和灵活性。
1. properties文件的基本概念在Java中,properties文件是一种简单的配置文件,通常以.key=value的形式存储配置信息。
它可以被用于各种用途,如国际化、设置参数、环境配置等。
在Java中,我们可以使用java.util.Properties类来操作properties文件,包括读取、写入和修改。
2. properties文件的读取与写入在Java中,我们可以使用Properties类的load和store方法来读取和写入properties文件。
通过load方法,我们可以将properties 文件中的配置信息加载到Properties对象中;而通过store方法,我们可以将Properties对象中的配置信息写入到properties文件中。
这种简单而直观的读取与写入方式使得properties文件在Java中被广泛应用。
3. properties文件的使用在Java开发中,properties文件可以用于各种情境。
我们可以将数据库的连接信息、系统的参数配置、界面的文本信息等存储在properties文件中,从而实现配置与代码的分离,方便后期的维护和修改。
在国际化开发中,properties文件也扮演着重要的角色,我们可以通过不同的properties文件实现不同语言环境下的文本切换。
4. 常见问题及解决方法在使用properties文件的过程中,我们常常会遇到各种问题。
如何处理中文乱码问题、如何实现动态更新properties文件、如何处理properties文件中的注释等。
.properties属性文件笔记
调用属性文件的方法
//实例化属性文件 属性文件集合 Properties pro=new Properties(); InputStream in=this.getClass().getResourceAsStream("jdbc.properties");//文件的相对路径 try {
pro.load(in);//需要抓取 } catch (IOException e) { e.printStackTrace(); } /* * pro.getProperty(KEY) KEY对应属性文件里的健 */
其他方法 件 笔 记
将连接数据库的一些常量放入其中,便于查看|修改|维护。
properties里用键值对的形式存储,每一行对应一个键和值,键=值 的形式,不加分号";"。
用来存储数据库的驱动类全名,URL,USER,PASSWORD键通常大写。
DRIVER=com.mysql.jdbc.Driver URL=jdbc:mysql://localhost/school?useUnicode=true&characterEncoding=UTF-8&useSSL=true USER=root PASSWORD=root
java基础--properties类使用
java基础--properties类使⽤⼀、Java Properties类Java中有个⽐较重要的类Properties(Java.util.Properties),主要⽤于读取Java的配置⽂件,各种语⾔都有⾃⼰所⽀持的配置⽂件,配置⽂件中很多变量是经常改变的,这样做也是为了⽅便⽤户,让⽤户能够脱离程序本⾝去修改相关的变量设置。
像Python⽀持的配置⽂件是.ini⽂件,同样,它也有⾃⼰读取配置⽂件的类ConfigParse,⽅便程序员或⽤户通过该类的⽅法来修改.ini配置⽂件。
在Java中,其配置⽂件常为.properties⽂件,格式为⽂本⽂件,⽂件的内容的格式是“键=值”的格式,⽂本注释信息可以⽤"#"来注释。
Properties类继承⾃Hashtable,如下:它提供了⼏个主要的⽅法:1. getProperty ( String key),⽤指定的键在此属性列表中搜索属性。
也就是通过参数 key ,得到 key 所对应的 value。
2. load ( InputStream inStream),从输⼊流中读取属性列表(键和元素对)。
通过对指定的⽂件(⽐如说上⾯的 test.properties ⽂件)进⾏装载来获取该⽂件中的所有键 - 值对。
以供 getProperty ( String key) 来搜索。
3. setProperty ( String key, String value) ,调⽤ Hashtable 的⽅法 put 。
他通过调⽤基类的put⽅法来设置键 - 值对。
4. store ( OutputStream out, String comments),以适合使⽤ load ⽅法加载到 Properties 表中的格式,将此 Properties 表中的属性列表(键和元素对)写⼊输出流。
与 load ⽅法相反,该⽅法将键 - 值对写⼊到指定的⽂件中去。
浅谈javaProperties类的使用基础
浅谈javaProperties类的使⽤基础Properties类继承⾃HashTable,通常和io流结合使⽤。
它最突出的特点是将key/value作为配置属性写⼊到配置⽂件中以实现配置持久化,或从配置⽂件中读取这些属性。
它的这些配置⽂件的规范后缀名为".properties"。
表⽰了⼀个持久的属性集。
需要注意⼏点:⽆论是key还是value,都必须是String数据类型。
虽然继承⾃HashTable,但它却没有使⽤泛型。
虽然可以使⽤HashTable的put⽅法,但不建议使⽤它,⽽是应该使⽤setProperty()⽅法。
多个线程可以共享单个Properties对象⽽⽆需进⾏外部同步。
即线程同步。
如果想将Properties集合中的属性集写⼊到配置⽂件中,使⽤store()⽅法;如果想从".properties"配置⽂件中读取属性,可以使⽤load()⽅法。
以下是Properties类的常⽤⽅法:setProperty(String k,String v):调⽤hashtable的put⽅法,向properties集合中添加key/value,返回值为key对应的旧值,如没有旧值则返回Null。
注意k和v都是String类型。
getProperty(String k):获取properties集合中key对应的value。
store(OutputStream o,String comment):将properties属性集合写⼊到输出流o中,注意,注释comment必不可少。
-load(InputStream i):从.properties配置⽂件中按照字节读取其中的属性。
load(Reader r):从.properties配置⽂件中按照字符读取其中的属性。
stringPropertyNames():返回properties集合中由key部分组成的Set集合。
properties用法
properties用法properties是Java中的关键字,用于描述和定义类的属性。
在Java中,类的属性可以被定义为具有不同的访问修饰符,如private、public、protected和默认访问修饰符。
属性表示了类的状态或特征,并且可以通过类的对象来访问和修改。
在本文中,我们将逐步回答properties的使用方法,并提供一些实例来帮助读者更好地理解。
第一步:属性定义属性可以作为类的成员变量来定义。
在Java中,我们可以使用访问修饰符来限制属性的访问权限。
例如,如果我们希望一个属性仅能在类内部访问,我们可以将它定义为私有属性(private),这样其他类的对象将无法直接访问该属性。
以下是一个私有属性的定义示例:javaprivate String name;在这个示例中,我们定义了一个私有属性name,它的类型是String。
只有在同一个类的方法中才能直接访问和修改name属性。
第二步:属性的访问与修改为了允许其他类的对象访问和修改属性,我们可以提供公共的访问方法。
在Java 中,这些方法通常被称为getter和setter方法。
getter方法用于获取属性的值,而setter方法用于设置属性的值。
以下是一个使用getter和setter方法访问属性的示例:javapublic String getName() {return name;}public void setName(String newName) {name = newName;}在这个示例中,我们定义了一个公共的getter方法getName(),它返回属性name的值。
另外,我们还定义了一个公共的setter方法setName(),它接收一个新的名字,用于修改属性name的值。
第三步:属性的初始化属性可以在定义时进行初始化,也可以在构造方法中进行初始化。
在Java中,我们可以在属性定义时为其赋予默认值。
以下是一个属性定义时进行初始化的示例:javaprivate int age = 18;在这个示例中,我们定义了一个私有属性age,并将其初始化为18。
浅谈java的Properties类
浅谈java的Properties类1.Properties类概述java.util.Properties继承⾃Hashtable,⽤来表⽰⼀个持久的属性集。
它使⽤键值结构存储数据,每个键及其对应值都是⼀个字符串。
该类也被许多Java类使⽤,⽐如获取系统属性时,System.getProperties⽅法就是返回⼀个Properties对象。
Hashtable是Map集合的实现类,它是最早期的⼀个双列结合,由于它⾃⾝是单线程的,已被 Hashmap给取代了,但是它的⼦类Properties仍然活跃在历史舞台,它是唯⼀⼀个与IO流结合的集合。
Properties数据可取⾃流中(从流中加载),也可以将数据存⼊到流中。
2.Properties类的常⽤⽅法(1)构造⽅法public Properties()//创建⼀个空的属性列表。
(2)功能性⽅法public Object setProperty(String key, String value) // 向属性集添加⼀对属性,第⼀个参数为键名,第⼆个参数为键值,传递的参数均是字符串类型数据public String getProperty(String key) //根据键的名称搜索集合中的键值public Set<String> stringPropertyNames() //⽤于遍历集合中所有的键值对(3)与流相关的⽅法//load⽅法的功能是:从硬盘中保存的键值对⽂件读取到内存中使⽤。
//具体的做法是:将传⼊的流中的数据加载进内存,传⼊的流可以是字节输⼊流,也可以是字符输⼊流。
public void load(InputStream inStream) //传⼊的参数为字节输⼊流,不能读含有中⽂的键值对。
public void load(Reader reader) // 从字符输⼊流中读取键值对,可以读取含有中⽂的键值对。
3.Properties的应⽤举例1.读取配置⽂件时使⽤。
properties常见用法
properties常见用法Properties 是 Java 中一个非常常用的类,它用于存储键值对,可以用来读取、写入配置文件,或者进行数据库连接配置等。
以下是Properties 类的常见用法:1. 创建 Properties 对象:javaProperties prop = new Properties();2. 使用setProperty()方法添加键值对:javaprop.setProperty("key1", "value1");prop.setProperty("key2", "value2");3. 使用getProperty()方法获取值:javaString value1 = prop.getProperty("key1");String value2 = prop.getProperty("key2");4. 从输入流中读取属性列表(键和元素对):javaInputStream inStream = newFileInputStream("config.properties");prop.load(inStream);5. 从字符流中读取属性列表(键和元素对):javaReader reader = new FileReader("config.properties"); prop.load(reader);6. 将 Properties 对象写入输出流:javaOutputStream outStream = newFileOutputStream("config.properties");prop.store(outStream, "This is a comment");7. 从 XML 文档加载属性到 Properties 对象:javaInputStream in = new FileInputStream("config.xml"); prop.loadFromXML(in);。
java集合(四)Map集合之Properties详解
java集合(四)Map集合之Properties详解⼀、Properties类介绍java.util.Properties继承⾃java.util.Hashtable,从jdk1.1版本开始,Properties的实现基本上就没有什么⼤的变动。
从/javase/7/docs/api/的jdk7的官⽅api⽂档中我们可以看到对Properties类的介绍。
Properties class是⼀个持久化的属性保存对象,可以将属性内容写出到stream中或者从stream中读取属性内容,在底层的Hashtable中,每⼀对属性的key和value都是按照string类型来保存的。
Properties可以将其他的Properties对象作为默认的值,Properties继承⾃Hashtable,所以Hashtable的所有⽅法Properties对象均可以访问。
Properties⽀持⽂本⽅式和xml⽅式的数据存储。
在⽂本⽅式中,格式为key:value,其中分隔符可以是:冒号(:)、等号(=)、空格。
其中空格可以作为key的结束,同时获取的值回将分割符号两端的空格去掉。
Properties只⽀持1对1模式的属性设置,⽽且不⽀持多层多级属性设置。
⼆、Properties类属性protected Properties defaults:包含默认values的Properties对象,默认为null。
我们在找不到对应key的情况下,就回递归的从这个默认列表中⾥⾯来找。
/*** A property list that contains default values for any keys not* found in this property list.** @serial*/protected Properties defaults;Properties property三、初始化⽅法Properties提供两种⽅式来创建Properties对象,第⼀种是不指定默认values对象的创建⽅法,另外⼀种是指定默认values对象的创建⽅法。
JAVA项目之Properties及国际化
* @DESCR:
*
*
通过资源文件的File对象,加载资源文件<br/>
*
*
多个异常的处理主要有二个目的<br/>
*
1、确保程序的执行顺序正确,当文件不存在时,下面的代码没有执行的必要。<br/>
*
2、确保已经打开的资源,要关闭<br/>
*
* @param @param baseFile
* @return void
import mon.bundle.IBundle; import mon.logger.Log; import mon.util.StringUtil;
/**
* @ClassName: PropertiesBundle
* @DESCR:
*
*
为了提高程序的灵活性,经常将一些配置性性,保存在配置文件而不是直接写在代码中<br/>
*
这样当需要进行变更时,不需要修改源代码,便与维护。<br/>
*
实现将配置文件转变了Properties,便于键值的查询。<br/>
*
IBundle 对 Properties 进行了封装,增加功能便于使用(检查更新,路径查找、组合)。<br/>
initialized with a File."); }
this._baseFile = baseFile; this._lastModified = stModified();
// this._bis 赋值时,FileNotFoundException 出现时终止程序继续执行 this._bis = new BufferedInputStream(new FileInputStream(this._baseFile)); ("Properties file path = " + this._baseFile.getAbsolutePath());
java读取properties文件总结
java读取properties文件总结一、java读取properties文件总结在java项目中,操作properties文件是经常要做的,因为很多的配置信息都会写在properties文件中,这里主要是总结使用getResourceAsStream方法和InputStream流去读取properties文件,使用getResourceAsStream方法去读取properties文件时需要特别注意properties文件路径的写法,测试项目如下:1.1.项目的目录结构1.2. java读取properties文件代码测试复制代码/* 范例名称:java读取properties文件总结* 源文件名称:PropertiesFileReadTest.java* 要点:* 1. 使用getResourceAsStream方法读取properties文件* 2. 使用InPutStream流读取properties文件* 3. 读取properties文件的路径写法问题* 时间:2014/4/2*/package propertiesFile.read.test;import java.io.BufferedInputStream;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStream;import java.text.MessageFormat;import java.util.Properties;public class PropertiesFileReadTest {/*** @param args*/public static void main(String[] args) {try {readPropFileByGetResourceAsStream();System.out.println("");readPropFileByInPutStream();} catch (Exception e) {e.printStackTrace();// TODO: handle exception}}/*** 使用getResourceAsStream方法读取properties文件*/static void readPropFileByGetResourceAsStream() {/*** 读取src下面config.properties包内的配置文件* test1.properties位于config.properties包内*/InputStream in1 = PropertiesFileReadTest.class.getClassLoader().getResourceAsStream("config/properties/test1.properties");/*** 读取和PropertiesFileReadTest类位于同一个包里面的配置文件* test2.properties和PropertiesFileReadTest类在同一个包里面*/InputStream in2 = PropertiesFileReadTest.class.getResourceAsStream("test2.properties");/*** 读取src根目录下文件的配置文件* jdbc.properties位于src目录*/InputStream in3 = PropertiesFileReadTest.class.getClassLoader().getResourceAsStream("jdbc.properties");/*** 读取位于另一个source文件夹里面的配置文件* config是一个source文件夹,config.properties位于config source文件夹中*/InputStream in4 = PropertiesFileReadTest.class.getClassLoader().getResourceAsStream("config.properties");Properties p = new Properties();System.out.println("----使用getResourceAsStream方法读取properties文件----");try {System.out.println("----------------------------------------------");p.load(in1);System.out.println("test1.properties:name=" + p.getProperty("name")+ ",age=" + p.getProperty("age"));System.out.println("----------------------------------------------");p.load(in2);System.out.println("test2.properties:name=" + p.getProperty("name") + ",age=" + p.getProperty("age"));System.out.println("----------------------------------------------");p.load(in3);System.out.println("jdbc.properties:");System.out.println(String.format("jdbc.driver=%s",p.getProperty("jdbc.driver")));// 这里的%s是java String占位符System.out.println(String.format("jdbc.url=%s",p.getProperty ("jdbc.url")));System.out.println(String.format("ename=%s",p.getProperty("ename")));System.out.println(String.format("jdbc.password=%s",p.getProperty("jdbc.password")));System.out.println("----------------------------------------------");p.load(in4);System.out.println("config.properties:");System.out.println(MessageFormat.format("dbuser={0}",p.getProperty("dbuser")));// {0}是一个java的字符串占位符System.out.println(MessageFormat.format("dbpassword={0}",p.getProperty("dbpassword")));System.out.println(MessageFormat.format("database={0}",p.getProperty("database")));System.out.println("----------------------------------------------");} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {if (in1 != null) {try {in1.close();} catch (IOException e) {e.printStackTrace();}}if (in2 != null) {try {in2.close();} catch (IOException e) {e.printStackTrace();}}if (in3 != null) {try {in3.close();} catch (IOException e) {e.printStackTrace();}}if (in4 != null) {try {in4.close();} catch (IOException e) {e.printStackTrace();}}}}/*** 使用InPutStream流读取properties文件*/static void readPropFileByInPutStream() {InputStream in1 = null;InputStream in2 = null;InputStream in3 = null;InputStream in4 = null;System.out.println("----使用InputStream流读取properties文件----");try {/*** 读取src根目录下文件的配置文件* jdbc.properties位于src目录*/in1 = new BufferedInputStream(new FileInputStream("src/jdbc.properties"));/*** 读取src下面config.properties包内的配置文件* test1.properties位于config.properties包内*/in2 = new BufferedInputStream(new FileInputStream("src/config/properties/test1.properties"));/*** 读取和PropertiesFileReadTest类位于同一个包里面的配置文件* test2.properties和PropertiesFileReadTest类在同一个包里面*/in3 = new BufferedInputStream(new FileInputStream("src/propertiesFile/read/test/test2.properties"));/*** 读取位于另一个source文件夹里面的配置文件* config是一个source文件夹,config.properties位于config source文件夹中*/in4 = new FileInputStream("config/config.properties");Properties p = new Properties();System.out.println("----------------------------------------------");p.load(in1);System.out.println("jdbc.properties:");System.out.println(String.format("jdbc.driver=%s",p.getProperty("jdbc.driver")));// 这里的%s是java String占位符System.out.println(String.format("jdbc.url=%s",p.getProperty("jdbc.url")));System.out.println(String.format("ename=%s",p.getProperty("ename")));System.out.println(String.format("jdbc.password=%s",p.getProperty("jdbc.password")));System.out.println("----------------------------------------------");p.load(in2);System.out.println("test1.properties:name=" + p.getProperty("name")+ ",age=" + p.getProperty("age"));System.out.println("----------------------------------------------");p.load(in3);System.out.println("test2.properties:name=" + p.getProperty("name")+ ",age=" + p.getProperty("age"));System.out.println("----------------------------------------------");p.load(in4);System.out.println("config.properties:");System.out.println(MessageFormat.format("dbuser={0}",p.getProperty("dbuser")));// {0}是一个java的字符串占位符System.out.println(MessageFormat.format("dbpassword={0}",p.getProperty("dbpassword")));System.out.println(MessageFormat.format("database={0}",p.getProperty("database")));System.out.println("----------------------------------------------");} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (in1 != null) {try {in1.close();} catch (IOException e) {e.printStackTrace();}}if (in2 != null) {try {in2.close();} catch (IOException e) {e.printStackTrace();}}if (in3 != null) {try {in3.close();} catch (IOException e) {e.printStackTrace();}}if (in4 != null) {try {in4.close();} catch (IOException e) {e.printStackTrace();}}}}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
java Properties类学习笔记
学习目标:
1、认识properties文件,理解其含义,会正确创建properties文件。
2、会使用java.util.Properties类来操作properties文件。
3、掌握相对路径,能正确书写一个properties文件的相对路径。
一、认识properties文件
1、properties文件是一个文本文件
2、properties文件的语法有两种,一种是注释,一种属性配置。
注释:前面加上#号
属性配置:以“键=值”的方式书写一个属性的配置信息。
3、properties文件的一个属性配置信息值可以换行,但键不可以换行。
值换行用“\”表示。
4、properties的属性配置键值前后的空格在解析时候会被忽略。
5、properties文件可以只有键而没有值。
也可以仅有键和等号而没有值,但无论如何一个属性配置不能没有键。
例如,下面一个properties文件:
#正确的properties配置文件
aaa=1\
11
b
bb=222
#格式良好的properties文件
aaa=111
bbb=222
二、解读java.util.Properties类
1、Properties类的层次结构
ng.Object
java.util.Dictionary<K,V>
java.util.Hashtable<Object,Object>
java.util.Properties
从层次机构看,Properties类实现了Map接口,因为HashTable实现了Map接口,因此Properties类本质上是一种简单的Map容器。
实际上,Properties类本身表示了对一种Map结构的操作。
properties文件本身就表示了一个“键值对”的集合。
因此,Properties类属于集合容器的家族,在使用前应该创建一个Properties的容器,实际上就是创建一个默认不带参数的Properties对象。
以后通过别的方式给里面添加“键值对”。
2、properties文件与Properties类的关系
通过properties文件可以填充Properties类。
也可以通过xml文件来填充Properties类。
可以通过绝对路径方式加载Properties文件信息,也可以使用相对路径加载。
三、实践
1、以绝对相对路径方式加载properties文件信息。
2、将Properties对象持久化到一个properties文件或者一个xml文件中。
3、修改并持久化properties文件。
测试代码:
测试的properties文件:
#格式良好的properties文件
aaa=111
bbb=222
测试类:
package stu;
import java.io.*;
import java.util.Properties;
/**
*Properties类测试
*User:xiaohui
*Date:2008-11-421:04:54
*/
public class TestProperties{
public static void main(String args[])throws IOException{
testProperties();
test1();
}
public static void testProperties()throws IOException{
System.out.println("------------testProperties-------------");
//将properties文件加载到输入字节流中
InputStream is
=new FileInputStream("D:\\myprojects\\lession4\\src\\stu\\ttt.properties");
//创建一个Properties容器
Properties prop=new Properties();
//从流中加载properties文件信息
prop.load(is);
//循环输出配置信息
for(Object key:prop.keySet()){
System.out.println(key+"="+prop.get(key));
}
//定义一个输出流
OutputStream os1=new FileOutputStream("C:\\ttt.xml");
OutputStream os2=new FileOutputStream("C:\\ttt.properties");
//从Properties对象导出导出到xml
prop.storeToXML(os1,"我从properties导出的XML配置文件");
//从Properties对象导出properties文件
prop.store(os2,"我从properties导出的XML配置文件");
is.close();
os1.close();
os2.close();
//从xml加载配置信息,填充Properties容器
prop.loadFromXML(new FileInputStream("C:\\ttt.xml"));
//循环输出配置信息
System.out.println("我从导出的xml加载配置文件信息!");
for(Object key:prop.keySet()){
System.out.println(key+"="+prop.get(key));
}
//修改Properties对象,并持久化到一个文件
prop.put("呵呵呵","嘎嘎嘎");
OutputStream os3=new FileOutputStream("C:\\ttt1.xml");
prop.storeToXML(os3,"我从properties导出的XML配置文件");
os3.close();
}
/**
*以相对路径方式加载properties文件
*
*@throws IOException
*/
public static void test1()throws IOException{
System.out.println("------------test1-------------");
Properties p=new Properties();
p.load(TestProperties.class.getResourceAsStream("/stu/ttt.properties"));
for(Object key:p.keySet()){
System.out.println(key+"="+p.get(key));
}
}
}
运行结果:
------------testProperties-------------
bbb=222
aaa=111
我从导出的xml加载配置文件信息!
bbb=222
aaa=111
------------test1-------------
bbb=222
aaa=111
Process finished with exit code0
C:盘下写入的文件如下:
呵呵,全部达到预期目标。