java Properties类学习笔记

合集下载

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程序配置参数(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 类表⽰了⼀个持久的属性集。

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配置⽂件⽅法总结⼀、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类的使用

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用法
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集合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工具类详解

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基础用法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用法

【主题】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属性文件笔记
看到一些文章说properti文件不要放在根目录下,不然不参与打包。
调用属性文件的方法
//实例化属性文件 属性文件集合 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中有个⽐较重要的类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类的使用基础

浅谈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用法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类

浅谈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常见用法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详解

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及国际化

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文件总结在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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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:盘下写入的文件如下:
呵呵,全部达到预期目标。

相关文档
最新文档