标签：object c nbsp eol origin rri lca print OWIN ISE
package java.util;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StreamCorruptedException;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import jdk.internal.misc.SharedSecrets;
import jdk.internal.util.xml.PropertiesDefaultHandler;
/**
* 1）Properties 文件表示一个持久的属性集，Properties 实例可以被保存到流中或从流加载。
* 2）Properties 实例可以包含一个默认的 Properties 对象，当属性在当前 Properties 中不存在时，
* 会尝试从默认的 Properties 中读取。
* 3）put 和 putAll 允许插入 Object 对象，不建议使用，建议通过 setProperties 方法添加属性。
* 4）集合视图 entrySet、keySet、values 返回的迭代器都是快速失败的。
* 5）Properties 继承了 Hashtable，Hashtable 继承了 Dictionary，键和值都不能为 null
*/
public
class Properties extends Hashtable<Object,Object> {
/**
* 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.
* 当键不存在时，默认查找的 Properties 对象
*/
protected Properties defaults;
/**
* Properties does not store values in its inherited Hashtable, but instead
* in an internal ConcurrentHashMap. Synchronization is omitted from
* simple read operations. Writes and bulk operations remain synchronized,
* as in Hashtable.
* 存储键值对的 ConcurrentHashMap 实例
*/
private transient ConcurrentHashMap<Object, Object> map;
/**
* Creates an empty property list with no default values.
* 创建一个容量为 8 的空 Properties 对象，没有默认的 Properties
*/
public Properties() {
this(null, 8);
}
/**
* Creates an empty property list with no default values, and with an
* initial size accommodating the specified number of elements without the
* need to dynamically resize.
* 创建一个容量为 initialCapacity 的空 Properties 对象，没有默认的 Properties
*/
public Properties(int initialCapacity) {
this(null, initialCapacity);
}
/**
* Creates an empty property list with the specified defaults.
* 创建一个容量为 8 的空 Properties 对象，并有默认的 Properties
*/
public Properties(Properties defaults) {
this(defaults, 8);
}
private Properties(Properties defaults, int initialCapacity) {
super((Void) null);
map = new ConcurrentHashMap<>(initialCapacity);
this.defaults = defaults;
}
/**
* Calls the {@code Hashtable} method {@code put}. Provided for
* parallelism with the {@code getProperty} method. Enforces use of
* strings for property keys and values. The value returned is the
* result of the {@code Hashtable} call to {@code put}.
* 通过 setProperty 方法设置新的键值对
*/
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.
*
* 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.
* 只有空格的行和以 # 或 ! 作为第一个非空字符的行都被忽略。
* 属性文件的格式可以是
* name=kristy
* name:kristy
* name kristy
* 从 Reader 中加载属性
*/
public synchronized void load(Reader reader) throws IOException {
Objects.requireNonNull(reader, "reader parameter is null");
load0(new LineReader(reader));
}
/**
* Reads a property list (key and element pairs) from the input
* byte stream. The input stream is in a simple line-oriented
* format as specified in
* {@link #load(java.io.Reader) load(Reader)} and is assumed to use
* the ISO 8859-1 character encoding.
* 从 InputStream 中加载属性
*/
public synchronized void load(InputStream inStream) throws IOException {
Objects.requireNonNull(inStream, "inStream parameter is null");
load0(new LineReader(inStream));
}
private void load0 (LineReader lr) throws IOException {
char[] convtBuf = new char[1024];
int limit;
int keyLen;
int valueStart;
char c;
boolean hasSep;
boolean precedingBackslash;
while ((limit = lr.readLine()) >= 0) {
c = 0;
keyLen = 0;
valueStart = limit;
hasSep = false;
//System.out.println("line=<" + new String(lineBuf, 0, limit) + ">");
precedingBackslash = false;
while (keyLen < limit) {
c = lr.lineBuf[keyLen];
//need check if escaped.
if ((c == ‘=‘ || c == ‘:‘) && !precedingBackslash) {
valueStart = keyLen + 1;
hasSep = true;
break;
} else if ((c == ‘ ‘ || c == ‘\t‘ || c == ‘\f‘) && !precedingBackslash) {
valueStart = keyLen + 1;
break;
}
if (c == ‘\\‘) {
precedingBackslash = !precedingBackslash;
} else {
precedingBackslash = false;
}
keyLen++;
}
while (valueStart < limit) {
c = lr.lineBuf[valueStart];
if (c != ‘ ‘ && c != ‘\t‘ && c != ‘\f‘) {
if (!hasSep && (c == ‘=‘ || c == ‘:‘)) {
hasSep = true;
} else {
break;
}
}
valueStart++;
}
String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);
String value = loadConvert(lr.lineBuf, valueStart, limit - valueStart, convtBuf);
put(key, value);
}
}
/* Read in a "logical line" from an InputStream/Reader, skip all comment
* and blank lines and filter out those leading whitespace characters
* (\u0020, \u0009 and \u000c) from the beginning of a "natural line".
* Method returns the char length of the "logical line" and stores
* the line in "lineBuf".
*/
class LineReader {
public LineReader(InputStream inStream) {
this.inStream = inStream;
inByteBuf = new byte[8192];
}
public LineReader(Reader reader) {
this.reader = reader;
inCharBuf = new char[8192];
}
byte[] inByteBuf;
char[] inCharBuf;
char[] lineBuf = new char[1024];
int inLimit = 0;
int inOff = 0;
InputStream inStream;
Reader reader;
int readLine() throws IOException {
int len = 0;
char c = 0;
boolean skipWhiteSpace = true;
boolean isCommentLine = false;
boolean isNewLine = true;
boolean appendedLineBegin = false;
boolean precedingBackslash = false;
boolean skipLF = false;
while (true) {
if (inOff >= inLimit) {
inLimit = (inStream==null)?reader.read(inCharBuf)
:inStream.read(inByteBuf);
inOff = 0;
if (inLimit <= 0) {
if (len == 0 || isCommentLine) {
return -1;
}
if (precedingBackslash) {
len--;
}
return len;
}
}
if (inStream != null) {
//The line below is equivalent to calling a
//ISO8859-1 decoder.
c = (char)(inByteBuf[inOff++] & 0xFF);
} else {
c = inCharBuf[inOff++];
}
if (skipLF) {
skipLF = false;
if (c == ‘\n‘) {
continue;
}
}
if (skipWhiteSpace) {
if (c == ‘ ‘ || c == ‘\t‘ || c == ‘\f‘) {
continue;
}
if (!appendedLineBegin && (c == ‘\r‘ || c == ‘\n‘)) {
continue;
}
skipWhiteSpace = false;
appendedLineBegin = false;
}
if (isNewLine) {
isNewLine = false;
if (c == ‘#‘ || c == ‘!‘) {
// Comment, quickly consume the rest of the line,
// resume on line-break and backslash.
if (inStream != null) {
while (inOff < inLimit) {
byte b = inByteBuf[inOff++];
if (b == ‘\n‘ || b == ‘\r‘ || b == ‘\\‘) {
c = (char)(b & 0xFF);
break;
}
}
} else {
while (inOff < inLimit) {
c = inCharBuf[inOff++];
if (c == ‘\n‘ || c == ‘\r‘ || c == ‘\\‘) {
break;
}
}
}
isCommentLine = true;
}
}
if (c != ‘\n‘ && c != ‘\r‘) {
lineBuf[len++] = c;
if (len == lineBuf.length) {
int newLength = lineBuf.length * 2;
if (newLength < 0) {
newLength = Integer.MAX_VALUE;
}
char[] buf = new char[newLength];
System.arraycopy(lineBuf, 0, buf, 0, lineBuf.length);
lineBuf = buf;
}
//flip the preceding backslash flag
if (c == ‘\\‘) {
precedingBackslash = !precedingBackslash;
} else {
precedingBackslash = false;
}
}
else {
// reached EOL
if (isCommentLine || len == 0) {
isCommentLine = false;
isNewLine = true;
skipWhiteSpace = true;
len = 0;
continue;
}
if (inOff >= inLimit) {
inLimit = (inStream==null)
?reader.read(inCharBuf)
:inStream.read(inByteBuf);
inOff = 0;
if (inLimit <= 0) {
if (precedingBackslash) {
len--;
}
return len;
}
}
if (precedingBackslash) {
len -= 1;
//skip the leading whitespace characters in following line
skipWhiteSpace = true;
appendedLineBegin = true;
precedingBackslash = false;
if (c == ‘\r‘) {
skipLF = true;
}
} else {
return len;
}
}
}
}
}
/*
* Converts encoded \uxxxx to unicode chars
* and changes special saved chars to their original forms
*/
private String loadConvert (char[] in, int off, int len, char[] convtBuf) {
if (convtBuf.length < len) {
int newLen = len * 2;
if (newLen < 0) {
newLen = Integer.MAX_VALUE;
}
convtBuf = new char[newLen];
}
char aChar;
char[] out = convtBuf;
int outLen = 0;
int end = off + len;
while (off < end) {
aChar = in[off++];
if (aChar == ‘\\‘) {
aChar = in[off++];
if(aChar == ‘u‘) {
// Read the xxxx
int value=0;
for (int i=0; i<4; i++) {
aChar = in[off++];
switch (aChar) {
case ‘0‘: case ‘1‘: case ‘2‘: case ‘3‘: case ‘4‘:
case ‘5‘: case ‘6‘: case ‘7‘: case ‘8‘: case ‘9‘:
value = (value << 4) + aChar - ‘0‘;
break;
case ‘a‘: case ‘b‘: case ‘c‘:
case ‘d‘: case ‘e‘: case ‘f‘:
value = (value << 4) + 10 + aChar - ‘a‘;
break;
case ‘A‘: case ‘B‘: case ‘C‘:
case ‘D‘: case ‘E‘: case ‘F‘:
value = (value << 4) + 10 + aChar - ‘A‘;
break;
default:
throw new IllegalArgumentException(
"Malformed \\uxxxx encoding.");
}
}
out[outLen++] = (char)value;
} else {
if (aChar == ‘t‘) aChar = ‘\t‘;
else if (aChar == ‘r‘) aChar = ‘\r‘;
else if (aChar == ‘n‘) aChar = ‘\n‘;
else if (aChar == ‘f‘) aChar = ‘\f‘;
out[outLen++] = aChar;
}
} else {
out[outLen++] = aChar;
}
}
return new String (out, 0, outLen);
}
/*
* Converts unicodes to encoded \uxxxx and escapes
* special characters with a preceding slash
*/
private String saveConvert(String theString,
boolean escapeSpace,
boolean escapeUnicode) {
int len = theString.length();
int bufLen = len * 2;
if (bufLen < 0) {
bufLen = Integer.MAX_VALUE;
}
StringBuilder outBuffer = new StringBuilder(bufLen);
for(int x=0; x<len; x++) {
char aChar = theString.charAt(x);
// Handle common case first, selecting largest block that
// avoids the specials below
if ((aChar > 61) && (aChar < 127)) {
if (aChar == ‘\\‘) {
outBuffer.append(‘\\‘); outBuffer.append(‘\\‘);
continue;
}
outBuffer.append(aChar);
continue;
}
switch(aChar) {
case ‘ ‘:
if (x == 0 || escapeSpace)
outBuffer.append(‘\\‘);
outBuffer.append(‘ ‘);
break;
case ‘\t‘:outBuffer.append(‘\\‘); outBuffer.append(‘t‘);
break;
case ‘\n‘:outBuffer.append(‘\\‘); outBuffer.append(‘n‘);
break;
case ‘\r‘:outBuffer.append(‘\\‘); outBuffer.append(‘r‘);
break;
case ‘\f‘:outBuffer.append(‘\\‘); outBuffer.append(‘f‘);
break;
case ‘=‘: // Fall through
case ‘:‘: // Fall through
case ‘#‘: // Fall through
case ‘!‘:
outBuffer.append(‘\\‘); outBuffer.append(aChar);
break;
default:
if (((aChar < 0x0020) || (aChar > 0x007e)) & escapeUnicode ) {
outBuffer.append(‘\\‘);
outBuffer.append(‘u‘);
outBuffer.append(toHex((aChar >> 12) & 0xF));
outBuffer.append(toHex((aChar >> 8) & 0xF));
outBuffer.append(toHex((aChar >> 4) & 0xF));
outBuffer.append(toHex( aChar & 0xF));
} else {
outBuffer.append(aChar);
}
}
}
return outBuffer.toString();
}
private static void writeComments(BufferedWriter bw, String comments)
throws IOException {
bw.write("#");
int len = comments.length();
int current = 0;
int last = 0;
char[] uu = new char[6];
uu[0] = ‘\\‘;
uu[1] = ‘u‘;
while (current < len) {
char c = comments.charAt(current);
if (c > ‘\u00ff‘ || c == ‘\n‘ || c == ‘\r‘) {
if (last != current)
bw.write(comments.substring(last, current));
if (c > ‘\u00ff‘) {
uu[2] = toHex((c >> 12) & 0xf);
uu[3] = toHex((c >> 8) & 0xf);
uu[4] = toHex((c >> 4) & 0xf);
uu[5] = toHex( c & 0xf);
bw.write(new String(uu));
} else {
bw.newLine();
if (c == ‘\r‘ &&
current != len - 1 &&
comments.charAt(current + 1) == ‘\n‘) {
current++;
}
if (current == len - 1 ||
(comments.charAt(current + 1) != ‘#‘ &&
comments.charAt(current + 1) != ‘!‘))
bw.write("#");
}
last = current + 1;
}
current++;
}
if (last != current)
bw.write(comments.substring(last, current));
bw.newLine();
}
/**
* Calls the {@code store(OutputStream out, String comments)} method
* and suppresses IOExceptions that were thrown.
*
* @deprecated This method does not throw an IOException if an I/O error
* occurs while saving the property list. The preferred way to save a
* properties list is via the {@code store(OutputStream out,
* String comments)} method or the
* {@code storeToXML(OutputStream os, String comment)} method.
*
* @param out an output stream.
* @param comments a description of the property list.
* @exception ClassCastException if this {@code Properties} object
* contains any keys or values that are not
* {@code Strings}.
*/
@Deprecated
public void save(OutputStream out, String comments) {
try {
store(out, comments);
} catch (IOException e) {
}
}
/**
* Writes this property list (key and element pairs) in this
* {@code Properties} table to the output character stream in a
* format suitable for using the {@link #load(java.io.Reader) load(Reader)}
* method.
* <p>
* Properties from the defaults table of this {@code Properties}
* table (if any) are <i>not</i> written out by this method.
* <p>
* If the comments argument is not null, then an ASCII {@code #}
* character, the comments string, and a line separator are first written
* to the output stream. Thus, the {@code comments} can serve as an
* identifying comment. Any one of a line feed (‘\n‘), a carriage
* return (‘\r‘), or a carriage return followed immediately by a line feed
* in comments is replaced by a line separator generated by the {@code Writer}
* and if the next character in comments is not character {@code #} or
* character {@code !} then an ASCII {@code #} is written out
* after that line separator.
* <p>
* Next, a comment line is always written, consisting of an ASCII
* {@code #} character, the current date and time (as if produced
* by the {@code toString} method of {@code Date} for the
* current time), and a line separator as generated by the {@code Writer}.
* <p>
* Then every entry in this {@code Properties} table is
* written out, one per line. For each entry the key string is
* written, then an ASCII {@code =}, then the associated
* element string. For the key, all space characters are
* written with a preceding {@code \} character. For the
* element, leading space characters, but not embedded or trailing
* space characters, are written with a preceding {@code \}
* character. The key and element characters {@code #},
* {@code !}, {@code =}, and {@code :} are written
* with a preceding backslash to ensure that they are properly loaded.
* <p>
* After the entries have been written, the output stream is flushed.
* The output stream remains open after this method returns.
* 将属性列表存储到 Writer 中，并添加相关注释
*/
public void store(Writer writer, String comments)
throws IOException
{
store0((writer instanceof BufferedWriter)?(BufferedWriter)writer
: new BufferedWriter(writer),
comments,
false);
}
/**
* Writes this property list (key and element pairs) in this
* {@code Properties} table to the output stream in a format suitable
* for loading into a {@code Properties} table using the
* {@link #load(InputStream) load(InputStream)} method.
* <p>
* Properties from the defaults table of this {@code Properties}
* table (if any) are <i>not</i> written out by this method.
* <p>
* This method outputs the comments, properties keys and values in
* the same format as specified in
* {@link #store(java.io.Writer, java.lang.String) store(Writer)},
* with the following differences:
* <ul>
* <li>The stream is written using the ISO 8859-1 character encoding.
*
* <li>Characters not in Latin-1 in the comments are written as
* {@code \u005Cu}<i>xxxx</i> for their appropriate unicode
* hexadecimal value <i>xxxx</i>.
*
* <li>Characters less than {@code \u005Cu0020} and characters greater
* than {@code \u005Cu007E} in property keys or values are written
* as {@code \u005Cu}<i>xxxx</i> for the appropriate hexadecimal
* value <i>xxxx</i>.
* </ul>
* <p>
* After the entries have been written, the output stream is flushed.
* The output stream remains open after this method returns.
* 将属性列表存储到 OutputStream 中，并添加相关注释
*/
public void store(OutputStream out, String comments)
throws IOException
{
store0(new BufferedWriter(new OutputStreamWriter(out, "8859_1")),
comments,
true);
}
private void store0(BufferedWriter bw, String comments, boolean escUnicode)
throws IOException
{
if (comments != null) {
writeComments(bw, comments);
}
bw.write("#" + new Date().toString());
bw.newLine();
synchronized (this) {
for (Map.Entry<Object, Object> e : entrySet()) {
String key = (String)e.getKey();
String val = (String)e.getValue();
key = saveConvert(key, true, escUnicode);
/* No need to escape embedded and trailing spaces for value, hence
* pass false to flag.
*/
val = saveConvert(val, false, escUnicode);
bw.write(key + "=" + val);
bw.newLine();
}
}
bw.flush();
}
/**
* Loads all of the properties represented by the XML document on the
* specified input stream into this properties table.
*
* <p>The XML document must have the following DOCTYPE declaration:
* <pre>
* <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
* </pre>
* Furthermore, the document must satisfy the properties DTD described
* above.
*
* <p> An implementation is required to read XML documents that use the
* "{@code UTF-8}" or "{@code UTF-16}" encoding. An implementation may
* support additional encodings.
*
* <p>The specified stream is closed after this method returns.
* 从 XML 文件中加载属性列表
*/
public synchronized void loadFromXML(InputStream in)
throws IOException, InvalidPropertiesFormatException
{
Objects.requireNonNull(in);
PropertiesDefaultHandler handler = new PropertiesDefaultHandler();
handler.load(this, in);
in.close();
}
/**
* Emits an XML document representing all of the properties contained
* in this table.
*
* <p> An invocation of this method of the form {@code props.storeToXML(os,
* comment)} behaves in exactly the same way as the invocation
* {@code 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 {@code 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}.
* 将属性列表存储到 XML 文件中，并添加相关注释
*/
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.
*
* <p>The XML document will have the following DOCTYPE declaration:
* <pre>
* <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
* </pre>
*
* <p>If the specified comment is {@code null} then no comment
* will be stored in the document.
*
* <p> 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.
*
* <p>The specified stream remains open after this method returns.
*
* <p>This method behaves the same as
* {@linkplain #storeToXML(OutputStream os, String comment, Charset charset)}
* except that it will {@linkplain java.nio.charset.Charset#forName look up the charset}
* using the given encoding name.
* 将属性列表存储到 XML 文件中，并添加相关注释，可以指定文件编码
*/
public void storeToXML(OutputStream os, String comment, String encoding)
throws IOException {
Objects.requireNonNull(os);
Objects.requireNonNull(encoding);
try {
Charset charset = Charset.forName(encoding);
storeToXML(os, comment, charset);
} catch (IllegalCharsetNameException | UnsupportedCharsetException e) {
throw new UnsupportedEncodingException(encoding);
}
}
/**
* Emits an XML document representing all of the properties contained
* in this table, using the specified encoding.
*
* <p>The XML document will have the following DOCTYPE declaration:
* <pre>
* <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
* </pre>
*
* <p>If the specified comment is {@code null} then no comment
* will be stored in the document.
*
* <p> 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.
*
* <p> Unmappable characters for the specified charset will be encoded as
* numeric character references.
*
* <p>The specified stream remains open after this method returns.
* 将属性列表存储到 XML 文件中，并添加相关注释，可以指定字符集
* @since 10
*/
public void storeToXML(OutputStream os, String comment, Charset charset)
throws IOException {
Objects.requireNonNull(os, "OutputStream");
Objects.requireNonNull(charset, "Charset");
PropertiesDefaultHandler handler = new PropertiesDefaultHandler();
handler.store(this, os, comment, charset);
}
/**
* 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.
* 根据指定的键读取属性值
*/
public String getProperty(String key) {
Object oval = map.get(key); // 从当前 Properties 中读取
String sval = (oval instanceof String) ? (String)oval : null; // 非字符串都返回 null
// 返回值为 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.
* 根据指定的键读取值，如果键不存在或值为 null，则返回 defaultValue
*/
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.
* 获取所有的属性名称
*/
public Enumeration<?> propertyNames() {
Hashtable<String,Object> h = new Hashtable<>();
enumerate(h);
return h.keys();
}
/**
* Returns an unmodifiable set of keys from 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 {@code String} are omitted.
* <p>
* The returned set is not backed by this {@code Properties} object.
* Changes to this {@code Properties} object are not reflected in the
* returned set.
* 获取所有的字符串属性名称
*/
public Set<String> stringPropertyNames() {
Map<String, String> h = new HashMap<>();
enumerateStringProperties(h);
return Collections.unmodifiableSet(h.keySet());
}
/**
* Prints this property list out to the specified output stream.
* This method is useful for debugging.
*/
public void list(PrintStream out) {
out.println("-- listing properties --");
Map<String, Object> h = new HashMap<>();
enumerate(h);
for (Map.Entry<String, Object> e : h.entrySet()) {
String key = e.getKey();
String val = (String)e.getValue();
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.
*/
public void list(PrintWriter out) {
out.println("-- listing properties --");
Map<String, Object> h = new HashMap<>();
enumerate(h);
for (Map.Entry<String, Object> e : h.entrySet()) {
String key = e.getKey();
String val = (String)e.getValue();
if (val.length() > 40) {
val = val.substring(0, 37) + "...";
}
out.println(key + "=" + val);
}
}
/**
* Enumerates all key/value pairs into the specified Map.
*/
private void enumerate(Map<String, Object> h) {
if (defaults != null) {
defaults.enumerate(h);
}
for (Map.Entry<Object, Object> e : entrySet()) {
String key = (String)e.getKey();
h.put(key, e.getValue());
}
}
/**
* Enumerates all key/value pairs into the specified Map
* and omits the property if the key or value is not a string.
*/
private void enumerateStringProperties(Map<String, String> h) {
if (defaults != null) {
defaults.enumerateStringProperties(h);
}
for (Map.Entry<Object, Object> e : entrySet()) {
Object k = e.getKey();
Object v = e.getValue();
if (k instanceof String && v instanceof String) {
h.put((String) k, (String) v);
}
}
}
/**
* Convert a nibble to a hex character
* 将整数转换为十六进制字符
*/
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‘
};
// Hashtable methods overridden and delegated to a ConcurrentHashMap instance
@Override
public int size() {
return map.size();
}
@Override
public boolean isEmpty() {
return map.isEmpty();
}
@Override
public Enumeration<Object> keys() {
// CHM.keys() returns Iterator w/ remove() - instead wrap keySet()
return Collections.enumeration(map.keySet());
}
@Override
public Enumeration<Object> elements() {
// CHM.elements() returns Iterator w/ remove() - instead wrap values()
return Collections.enumeration(map.values());
}
@Override
public boolean contains(Object value) {
return map.contains(value);
}
@Override
public boolean containsValue(Object value) {
return map.containsValue(value);
}
@Override
public boolean containsKey(Object key) {
return map.containsKey(key);
}
@Override
public Object get(Object key) {
return map.get(key);
}
@Override
public synchronized Object put(Object key, Object value) {
return map.put(key, value);
}
@Override
public synchronized Object remove(Object key) {
return map.remove(key);
}
@Override
public synchronized void putAll(Map<?, ?> t) {
map.putAll(t);
}
@Override
public synchronized void clear() {
map.clear();
}
@Override
public synchronized String toString() {
return map.toString();
}
@Override
public Set<Object> keySet() {
return Collections.synchronizedSet(map.keySet(), this);
}
@Override
public Collection<Object> values() {
return Collections.synchronizedCollection(map.values(), this);
}
@Override
public Set<Map.Entry<Object, Object>> entrySet() {
return Collections.synchronizedSet(new EntrySet(map.entrySet()), this);
}
/*
* Properties.entrySet() should not support add/addAll, however
* ConcurrentHashMap.entrySet() provides add/addAll. This class wraps the
* Set returned from CHM, changing add/addAll to throw UOE.
*/
private static class EntrySet implements Set<Map.Entry<Object, Object>> {
private Set<Map.Entry<Object,Object>> entrySet;
private EntrySet(Set<Map.Entry<Object, Object>> entrySet) {
this.entrySet = entrySet;
}
@Override public int size() { return entrySet.size(); }
@Override public boolean isEmpty() { return entrySet.isEmpty(); }
@Override public boolean contains(Object o) { return entrySet.contains(o); }
@Override public Object[] toArray() { return entrySet.toArray(); }
@Override public <T> T[] toArray(T[] a) { return entrySet.toArray(a); }
@Override public void clear() { entrySet.clear(); }
@Override public boolean remove(Object o) { return entrySet.remove(o); }
@Override
public boolean add(Map.Entry<Object, Object> e) {
throw new UnsupportedOperationException();
}
@Override
public boolean addAll(Collection<? extends Map.Entry<Object, Object>> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean containsAll(Collection<?> c) {
return entrySet.containsAll(c);
}
@Override
public boolean removeAll(Collection<?> c) {
return entrySet.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
return entrySet.retainAll(c);
}
@Override
public Iterator<Map.Entry<Object, Object>> iterator() {
return entrySet.iterator();
}
}
@Override
public synchronized boolean equals(Object o) {
return map.equals(o);
}
@Override
public synchronized int hashCode() {
return map.hashCode();
}
@Override
public Object getOrDefault(Object key, Object defaultValue) {
return map.getOrDefault(key, defaultValue);
}
@Override
public synchronized void forEach(BiConsumer<? super Object, ? super Object> action) {
map.forEach(action);
}
@Override
public synchronized void replaceAll(BiFunction<? super Object, ? super Object, ?> function) {
map.replaceAll(function);
}
@Override
public synchronized Object putIfAbsent(Object key, Object value) {
return map.putIfAbsent(key, value);
}
@Override
public synchronized boolean remove(Object key, Object value) {
return map.remove(key, value);
}
@Override
public synchronized boolean replace(Object key, Object oldValue, Object newValue) {
return map.replace(key, oldValue, newValue);
}
@Override
public synchronized Object replace(Object key, Object value) {
return map.replace(key, value);
}
@Override
public synchronized Object computeIfAbsent(Object key,
Function<? super Object, ?> mappingFunction) {
return map.computeIfAbsent(key, mappingFunction);
}
@Override
public synchronized Object computeIfPresent(Object key,
BiFunction<? super Object, ? super Object, ?> remappingFunction) {
return map.computeIfPresent(key, remappingFunction);
}
@Override
public synchronized Object compute(Object key,
BiFunction<? super Object, ? super Object, ?> remappingFunction) {
return map.compute(key, remappingFunction);
}
@Override
public synchronized Object merge(Object key, Object value,
BiFunction<? super Object, ? super Object, ?> remappingFunction) {
return map.merge(key, value, remappingFunction);
}
//
// Special Hashtable methods
@Override
protected void rehash() { /* no-op */ }
@Override
public synchronized Object clone() {
Properties clone = (Properties) cloneHashtable();
clone.map = new ConcurrentHashMap<>(map);
return clone;
}
// Hashtable serialization overrides
// (these should emit and consume Hashtable-compatible stream)
@Override
void writeHashtable(ObjectOutputStream s) throws IOException {
List<Object> entryStack = new ArrayList<>(map.size() * 2); // an estimate
for (Map.Entry<Object, Object> entry : map.entrySet()) {
entryStack.add(entry.getValue());
entryStack.add(entry.getKey());
}
// Write out the simulated threshold, loadfactor
float loadFactor = 0.75f;
int count = entryStack.size() / 2;
int length = (int)(count / loadFactor) + (count / 20) + 3;
if (length > count && (length & 1) == 0) {
length--;
}
synchronized (map) { // in case of multiple concurrent serializations
defaultWriteHashtable(s, length, loadFactor);
}
// Write out simulated length and real count of elements
s.writeInt(length);
s.writeInt(count);
// Write out the key/value objects from the stacked entries
for (int i = entryStack.size() - 1; i >= 0; i--) {
s.writeObject(entryStack.get(i));
}
}
@Override
void readHashtable(ObjectInputStream s) throws IOException,
ClassNotFoundException {
// Read in the threshold and loadfactor
s.defaultReadObject();
// Read the original length of the array and number of elements
int origlength = s.readInt();
int elements = s.readInt();
// Validate # of elements
if (elements < 0) {
throw new StreamCorruptedException("Illegal # of Elements: " + elements);
}
// Constructing the backing map will lazily create an array when the first element is
// added, so check it before construction. Note that CHM‘s constructor takes a size
// that is the number of elements to be stored -- not the table size -- so it must be
// inflated by the default load factor of 0.75, then inflated to the next power of two.
// (CHM uses the same power-of-two computation as HashMap, and HashMap.tableSizeFor is
// accessible here.) Check Map.Entry[].class since it‘s the nearest public type to
// what is actually created.
SharedSecrets.getJavaObjectInputStreamAccess()
.checkArray(s, Map.Entry[].class, HashMap.tableSizeFor((int)(elements / 0.75)));
// create CHM of appropriate capacity
map = new ConcurrentHashMap<>(elements);
// Read all the key/value objects
for (; elements > 0; elements--) {
Object key = s.readObject();
Object value = s.readObject();
map.put(key, value);
}
}
}
标签：object c nbsp eol origin rri lca print OWIN ISE
原文地址：https://www.cnblogs.com/zhuxudong/p/9350142.html
