Java中的Properties对象

Properties是Java中jdk自带的一个对象

我们可以直接将后缀为properties的文件变为Properties对象，然后通过Porperties对象中的方法对.properties文件对象进行操作。

package propertiesTset;import java.util.Properties;public class PropertiesTest {Properties pros = new Properties();try{FileInputStream fis = new FileInputStream(path);properties.load(fis);for(String name:props.StringPropertyNames()){objectPool.put(name:creatObject(props.getProperty(name)));}} catch (IOException e) {throw new RuntimeException("flyusercenter加载配置失败", e);}
}

.properties文件

funauthapp.color=blue
#funauthapp.func_permission_check=true
#funauthapp.authorized_user =
#funauthapp.authorized_group =
funauthapp.esopConnTimeout=5000
funauthapp.checkUserAppManageServiceName=mdm_restful-checkUserAppManage/ProxyService/restful-checkUserAppManageProxyService
funauthapp.syncDynamicGroupMemberCron=0 0/5 * * * ?
funauthapp.homepage.theme_mapping={"indigo":"blueback","green":"greenback","purple":"purpleback","cherry":"redback"}

方法列表：

源码

package java.util;import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.security.AccessController;
import java.security.PrivilegedAction;import sun.util.spi.XmlPropertiesProvider;/*** The {@code Properties} class represents a persistent set of* properties. The {@code Properties} can be saved to a stream* or loaded from a stream. Each key and its corresponding value in* the property list is a string.* 
* A property list can contain another property list as its* "defaults"; this second property list is searched if* the property key is not found in the original property list.* 
* Because {@code Properties} inherits from {@code Hashtable}, the* {@code put} and {@code putAll} methods can be applied to a* {@code Properties} object.  Their use is strongly discouraged as they* allow the caller to insert entries whose keys or values are not* {@code Strings}.  The {@code setProperty} method should be used* instead.  If the {@code store} or {@code save} method is called* on a "compromised" {@code Properties} object that contains a* non-{@code String} key or value, the call will fail. Similarly,* the call to the {@code propertyNames} or {@code list} method* will fail if it is called on a "compromised" {@code Properties}* object that contains a non-{@code String} key.** 
* The {@link #load(java.io.Reader) load(Reader)} /* {@link #store(java.io.Writer, java.lang.String) store(Writer, String)}* methods load and store properties from and to a character based stream* in a simple line-oriented format specified below.** The {@link #load(java.io.InputStream) load(InputStream)} /* {@link #store(java.io.OutputStream, java.lang.String) store(OutputStream, String)}* methods work the same way as the load(Reader)/store(Writer, String) pair, except* the input/output stream is encoded in ISO 8859-1 character encoding.* Characters that cannot be directly represented in this encoding can be written using* Unicode escapes as defined in section 3.3 of* The Java™ Language Specification;* only a single 'u' character is allowed in an escape* sequence. The native2ascii tool can be used to convert property files to and* from other character encodings.** 
 The {@link #loadFromXML(InputStream)} and {@link* #storeToXML(OutputStream, String, String)} methods load and store properties* in a simple XML format.  By default the UTF-8 character encoding is used,* however a specific encoding may be specified if required. Implementations* are required to support UTF-8 and UTF-16 and may support other encodings.* An XML properties document has the following DOCTYPE declaration:** 
* <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">* 
* Note that the system URI (http://java.sun.com/dtd/properties.dtd) is* not accessed when exporting or importing properties; it merely* serves as a string to uniquely identify the DTD, which is:* 
*    <?xml version="1.0" encoding="UTF-8"?>**    <!-- DTD for properties -->**    <!ELEMENT properties ( comment?, entry* ) >**    <!ATTLIST properties version CDATA #FIXED "1.0">**    <!ELEMENT comment (#PCDATA) >**    <!ELEMENT entry (#PCDATA) >**    <!ATTLIST entry key CDATA #REQUIRED>* 
** 
This class is thread-safe: multiple threads can share a single* Properties object without the need for external synchronization.** @see native2ascii tool for Solaris* @see native2ascii tool for Windows** @author  Arthur van Hoff* @author  Michael McCloskey* @author  Xueming Shen* @since   JDK1.0*/
public
class Properties extends Hashtable {/*** use serialVersionUID from JDK 1.1.X for interoperability*/private static final long serialVersionUID = 4112578634029874840L;/*** A property list that contains default values for any keys not* found in this property list.** @serial*/protected Properties defaults;/*** Creates an empty property list with no default values.*/public Properties() {this(null);}/*** Creates an empty property list with the specified defaults.** @param   defaults   the defaults.*/public Properties(Properties defaults) {this.defaults = defaults;}/*** Calls the Hashtable method {@code put}. Provided for* parallelism with the getProperty method. Enforces use of* strings for property keys and values. The value returned is the* result of the Hashtable call to {@code put}.** @param key the key to be placed into this property list.* @param value the value corresponding to key.* @return     the previous value of the specified key in this property*             list, or {@code null} if it did not have one.* @see #getProperty* @since    1.2*/public synchronized Object setProperty(String key, String value) {return put(key, value);}/*** Reads a property list (key and element pairs) from the input* character stream in a simple line-oriented format.* 
* Properties are processed in terms of lines. There are two* kinds of line, natural lines and logical lines.* A natural line is defined as a line of* characters that is terminated either by a set of line terminator* characters ({@code \n} or {@code \r} or {@code \r\n})* or by the end of the stream. A natural line may be either a blank line,* a comment line, or hold all or some of a key-element pair. A logical* line holds all the data of a key-element pair, which may be spread* out across several adjacent natural lines by escaping* the line terminator sequence with a backslash character* {@code \}.  Note that a comment line cannot be extended* in this manner; every natural line that is a comment must have* its own comment indicator, as described below. Lines are read from* input until the end of the stream is reached.** 
* A natural line that contains only white space characters is* considered blank and is ignored.  A comment line has an ASCII* {@code '#'} or {@code '!'} as its first non-white* space character; comment lines are also ignored and do not* encode key-element information.  In addition to line* terminators, this format considers the characters space* ({@code ' '}, {@code '\u005Cu0020'}), tab* ({@code '\t'}, {@code '\u005Cu0009'}), and form feed* ({@code '\f'}, {@code '\u005Cu000C'}) to be white* space.** 
* If a logical line is spread across several natural lines, the* backslash escaping the line terminator sequence, the line* terminator sequence, and any white space at the start of the* following line have no affect on the key or element values.* The remainder of the discussion of key and element parsing* (when loading) will assume all the characters constituting* the key and element appear on a single natural line after* line continuation characters have been removed.  Note that* it is not sufficient to only examine the character* preceding a line terminator sequence to decide if the line* terminator is escaped; there must be an odd number of* contiguous backslashes for the line terminator to be escaped.* Since the input is processed from left to right, a* non-zero even number of 2n contiguous backslashes* before a line terminator (or elsewhere) encodes n* backslashes after escape processing.** 
* The key contains all of the characters in the line starting* with the first non-white space character and up to, but not* including, the first unescaped {@code '='},* {@code ':'}, or white space character other than a line* terminator. All of these key termination characters may be* included in the key by escaping them with a preceding backslash* character; for example,
** {@code \:\=}
** would be the two-character key {@code ":="}.  Line* terminator characters can be included using {@code \r} and* {@code \n} escape sequences.  Any white space after the* key is skipped; if the first non-white space character after* the key is {@code '='} or {@code ':'}, then it is* ignored and any white space characters after it are also* skipped.  All remaining characters on the line become part of* the associated element string; if there are no remaining* characters, the element is the empty string* {@code ""}.  Once the raw character sequences* constituting the key and element are identified, escape* processing is performed as described above.** 
* As an example, each of the following three lines specifies the key* {@code "Truth"} and the associated element value* {@code "Beauty"}:* 
* Truth = Beauty*  Truth:Beauty* Truth                    :Beauty* 
* As another example, the following three lines specify a single* property:* 
* fruits                           apple, banana, pear, \*                                  cantaloupe, watermelon, \*                                  kiwi, mango* 
* The key is {@code "fruits"} and the associated element is:* 
"apple, banana, pear, cantaloupe, watermelon, kiwi, mango"
* Note that a space appears before each {@code \} so that a space* will appear after each comma in the final result; the {@code \},* line terminator, and leading white space on the continuation line are* merely discarded and are not replaced by one or more other* characters.* 
* As a third example, the line:* 
cheeses* 
* specifies that the key is {@code "cheeses"} and the associated* element is the empty string {@code ""}.* 
* Character*         Encoding in Entities* @since 1.5*/public synchronized void loadFromXML(InputStream in)throws IOException, InvalidPropertiesFormatException{XmlSupport.load(this, Objects.requireNonNull(in));in.close();}/*** Emits an XML document representing all of the properties contained* in this table.** 
 An invocation of this method of the form props.storeToXML(os,* comment) behaves in exactly the same way as the invocation* props.storeToXML(os, comment, "UTF-8");.** @param os the output stream on which to emit the XML document.* @param comment a description of the property list, or {@code null}*        if no comment is desired.* @throws IOException if writing to the specified output stream*         results in an IOException.* @throws NullPointerException if {@code os} is null.* @throws ClassCastException  if this {@code Properties} object*         contains any keys or values that are not*         {@code Strings}.* @see    #loadFromXML(InputStream)* @since 1.5*/public void storeToXML(OutputStream os, String comment)throws IOException{storeToXML(os, comment, "UTF-8");}/*** Emits an XML document representing all of the properties contained* in this table, using the specified encoding.** 
The XML document will have the following DOCTYPE declaration:* 
* <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">* 
** 
If the specified comment is {@code null} then no comment* will be stored in the document.** 
 An implementation is required to support writing of XML documents* that use the "{@code UTF-8}" or "{@code UTF-16}" encoding. An* implementation may support additional encodings.** 
The specified stream remains open after this method returns.** @param os        the output stream on which to emit the XML document.* @param comment   a description of the property list, or {@code null}*                  if no comment is desired.* @param  encoding the name of a supported*                  *                  character encoding** @throws IOException if writing to the specified output stream*         results in an IOException.* @throws java.io.UnsupportedEncodingException if the encoding is not*         supported by the implementation.* @throws NullPointerException if {@code os} is {@code null},*         or if {@code encoding} is {@code null}.* @throws ClassCastException  if this {@code Properties} object*         contains any keys or values that are not*         {@code Strings}.* @see    #loadFromXML(InputStream)* @see    Character*         Encoding in Entities* @since 1.5*/public void storeToXML(OutputStream os, String comment, String encoding)throws IOException{XmlSupport.save(this, Objects.requireNonNull(os), comment,Objects.requireNonNull(encoding));}/*** Searches for the property with the specified key in this property list.* If the key is not found in this property list, the default property list,* and its defaults, recursively, are then checked. The method returns* {@code null} if the property is not found.** @param   key   the property key.* @return  the value in this property list with the specified key value.* @see     #setProperty* @see     #defaults*/public String getProperty(String key) {Object oval = super.get(key);String sval = (oval instanceof String) ? (String)oval : null;return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval;}/*** Searches for the property with the specified key in this property list.* If the key is not found in this property list, the default property list,* and its defaults, recursively, are then checked. The method returns the* default value argument if the property is not found.** @param   key            the hashtable key.* @param   defaultValue   a default value.** @return  the value in this property list with the specified key value.* @see     #setProperty* @see     #defaults*/public String getProperty(String key, String defaultValue) {String val = getProperty(key);return (val == null) ? defaultValue : val;}/*** Returns an enumeration of all the keys in this property list,* including distinct keys in the default property list if a key* of the same name has not already been found from the main* properties list.** @return  an enumeration of all the keys in this property list, including*          the keys in the default property list.* @throws  ClassCastException if any key in this property list*          is not a string.* @see     java.util.Enumeration* @see     java.util.Properties#defaults* @see     #stringPropertyNames*/public Enumeration propertyNames() {Hashtable h = new Hashtable<>();enumerate(h);return h.keys();}/*** Returns a set of keys in this property list where* the key and its corresponding value are strings,* including distinct keys in the default property list if a key* of the same name has not already been found from the main* properties list.  Properties whose key or value is not* of type String are omitted.* 
* The returned set is not backed by the Properties object.* Changes to this Properties are not reflected in the set,* or vice versa.** @return  a set of keys in this property list where*          the key and its corresponding value are strings,*          including the keys in the default property list.* @see     java.util.Properties#defaults* @since   1.6*/public Set stringPropertyNames() {Hashtable h = new Hashtable<>();enumerateStringProperties(h);return h.keySet();}/*** Prints this property list out to the specified output stream.* This method is useful for debugging.** @param   out   an output stream.* @throws  ClassCastException if any key in this property list*          is not a string.*/public void list(PrintStream out) {out.println("-- listing properties --");Hashtable h = new Hashtable<>();enumerate(h);for (Enumeration e = h.keys() ; e.hasMoreElements() ;) {String key = e.nextElement();String val = (String)h.get(key);if (val.length() > 40) {val = val.substring(0, 37) + "...";}out.println(key + "=" + val);}}/*** Prints this property list out to the specified output stream.* This method is useful for debugging.** @param   out   an output stream.* @throws  ClassCastException if any key in this property list*          is not a string.* @since   JDK1.1*//** Rather than use an anonymous inner class to share common code, this* method is duplicated in order to ensure that a non-1.1 compiler can* compile this file.*/public void list(PrintWriter out) {out.println("-- listing properties --");Hashtable h = new Hashtable<>();enumerate(h);for (Enumeration e = h.keys() ; e.hasMoreElements() ;) {String key = e.nextElement();String val = (String)h.get(key);if (val.length() > 40) {val = val.substring(0, 37) + "...";}out.println(key + "=" + val);}}/*** Enumerates all key/value pairs in the specified hashtable.* @param h the hashtable* @throws ClassCastException if any of the property keys*         is not of String type.*/private synchronized void enumerate(Hashtable h) {if (defaults != null) {defaults.enumerate(h);}for (Enumeration e = keys() ; e.hasMoreElements() ;) {String key = (String)e.nextElement();h.put(key, get(key));}}/*** Enumerates all key/value pairs in the specified hashtable* and omits the property if the key or value is not a string.* @param h the hashtable*/private synchronized void enumerateStringProperties(Hashtable h) {if (defaults != null) {defaults.enumerateStringProperties(h);}for (Enumeration e = keys() ; e.hasMoreElements() ;) {Object k = e.nextElement();Object v = get(k);if (k instanceof String && v instanceof String) {h.put((String) k, (String) v);}}}/*** Convert a nibble to a hex character* @param   nibble  the nibble to convert.*/private static char toHex(int nibble) {return hexDigit[(nibble & 0xF)];}/** A table of hex digits */private static final char[] hexDigit = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};/*** Supporting class for loading/storing properties in XML format.** 
 The {@code load} and {@code store} methods defined here delegate to a* system-wide {@code XmlPropertiesProvider}. On first invocation of either* method then the system-wide provider is located as follows: 
** 
*   
 If the system property {@code sun.util.spi.XmlPropertiesProvider}*   is defined then it is taken to be the full-qualified name of a concrete*   provider class. The class is loaded with the system class loader as the*   initiating loader. If it cannot be loaded or instantiated using a zero*   argument constructor then an unspecified error is thrown. 
**   
 If the system property is not defined then the service-provider*   loading facility defined by the {@link ServiceLoader} class is used to*   locate a provider with the system class loader as the initiating*   loader and {@code sun.util.spi.XmlPropertiesProvider} as the service*   type. If this process fails then an unspecified error is thrown. If*   there is more than one service provider installed then it is*   not specified as to which provider will be used. 
**   
 If the provider is not found by the above means then a system*   default provider will be instantiated and used. 
* 
*/private static class XmlSupport {private static XmlPropertiesProvider loadProviderFromProperty(ClassLoader cl) {String cn = System.getProperty("sun.util.spi.XmlPropertiesProvider");if (cn == null)return null;try {Class c = Class.forName(cn, true, cl);return (XmlPropertiesProvider)c.newInstance();} catch (ClassNotFoundException |IllegalAccessException |InstantiationException x) {throw new ServiceConfigurationError(null, x);}}private static XmlPropertiesProvider loadProviderAsService(ClassLoader cl) {Iterator iterator =ServiceLoader.load(XmlPropertiesProvider.class, cl).iterator();return iterator.hasNext() ? iterator.next() : null;}private static XmlPropertiesProvider loadProvider() {return AccessController.doPrivileged(new PrivilegedAction() {public XmlPropertiesProvider run() {ClassLoader cl = ClassLoader.getSystemClassLoader();XmlPropertiesProvider provider = loadProviderFromProperty(cl);if (provider != null)return provider;provider = loadProviderAsService(cl);if (provider != null)return provider;return new jdk.internal.util.xml.BasicXmlPropertiesProvider();}});}private static final XmlPropertiesProvider PROVIDER = loadProvider();static void load(Properties props, InputStream in)throws IOException, InvalidPropertiesFormatException{PROVIDER.load(props, in);}static void save(Properties props, OutputStream os, String comment,String encoding)throws IOException{PROVIDER.store(props, os, comment, encoding);}}
}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！