properties.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 509 行 · 第 1/2 页

						pos = 0;
						while (pos < line.length() && Character.isWhitespace(c = line.charAt(pos)))
							pos++;
						element.ensureCapacity(line.length() - pos + element.length());
					} else {
						c = line.charAt(pos++);
						switch (c) {
							case 'n' :
								element.append('\n');
								break;
							case 't' :
								element.append('\t');
								break;
							case 'r' :
								element.append('\r');
								break;
							case 'u' :
								if (pos + 4 <= line.length()) {
									char uni = (char) Integer.parseInt(line.substring(pos, pos + 4), 16);
									element.append(uni);
									pos += 4;
								} // else throw exception?
								break;
							default :
								element.append(c);
								break;
						}
					}
				} else
					element.append(c);
			}
			put(key.toString(), element.toString());
		}
	}

	/**
	 * Calls <code>store(OutputStream out, String header)</code> and
	 * ignores the IOException that may be thrown.
	 *
	 * @param out the stream to write to
	 * @param header a description of the property list
	 * @throws ClassCastException if this property contains any key or
	 *         value that are not strings
	 * @deprecated use {@link #store(OutputStream, String)} instead
	 */
	public void save(OutputStream out, String header) {
		try {
			store(out, header);
		} catch (IOException ex) {
		}
	}

	/**
	 * Writes the key/value pairs to the given output stream, in a format
	 * suitable for <code>load</code>.<br>
	 *
	 * If header is not null, this method writes a comment containing
	 * the header as first line to the stream.  The next line (or first
	 * line if header is null) contains a comment with the current date.
	 * Afterwards the key/value pairs are written to the stream in the
	 * following format.<br>
	 *
	 * Each line has the form <code>key = value</code>.  Newlines,
	 * Returns and tabs are written as <code>\n,\t,\r</code> resp.
	 * The characters <code>\, !, #, =</code> and <code>:</code> are
	 * preceeded by a backslash.  Spaces are preceded with a backslash,
	 * if and only if they are at the beginning of the key.  Characters
	 * that are not in the ascii range 33 to 127 are written in the
	 * <code>\</code><code>u</code>xxxx Form.<br>
	 *
	 * Following the listing, the output stream is flushed but left open.
	 *
	 * @param out the output stream
	 * @param header the header written in the first line, may be null
	 * @throws ClassCastException if this property contains any key or
	 *         value that isn't a string
	 * @throws IOException if writing to the stream fails
	 * @throws NullPointerException if out is null
	 * @since 1.2
	 */
	public void store(OutputStream out, String header) throws IOException {
		// The spec says that the file must be encoded using ISO-8859-1.
		PrintWriter writer = new PrintWriter(new OutputStreamWriter(out, "ISO-8859-1"));
		if (header != null)
			writer.println("#" + header);
		writer.println("#" + new Date());
		list(writer);
		writer.flush();
	}

	/**
	 * Gets the property with the specified key in this property list.
	 * If the key is not found, the default property list is searched.
	 * If the property is not found in the default, null is returned.
	 *
	 * @param key The key for this property
	 * @return the value for the given key, or null if not found
	 * @throws ClassCastException if this property contains any key or
	 *         value that isn't a string
	 * @see #defaults
	 * @see #setProperty(String, String)
	 * @see #getProperty(String, String)
	 */
	public String getProperty(String key) {
		return getProperty(key, null);
	}

	/**
	 * Gets the property with the specified key in this property list.  If
	 * the key is not found, the default property list is searched.  If the
	 * property is not found in the default, the specified defaultValue is
	 * returned.
	 *
	 * @param key The key for this property
	 * @param defaultValue A default value
	 * @return The value for the given key
	 * @throws ClassCastException if this property contains any key or
	 *         value that isn't a string
	 * @see #defaults
	 * @see #setProperty(String, String)
	 */
	public String getProperty(String key, String defaultValue) {
		Properties prop = this;
		// Eliminate tail recursion.
		do {
			String value = (String) prop.get(key);
			if (value != null)
				return value;
			prop = prop.defaults;
		} while (prop != null);
		return defaultValue;
	}

	/**
	 * Returns an enumeration of all keys in this property list, including
	 * the keys in the default property list.
	 *
	 * @return an Enumeration of all defined keys
	 */
	public Enumeration propertyNames() {
		// We make a new Set that holds all the keys, then return an enumeration
		// for that. This prevents modifications from ruining the enumeration,
		// as well as ignoring duplicates.
		Properties prop = this;
		Set s = new HashSet();
		// Eliminate tail recursion.
		do {
			s.addAll(prop.keySet());
			prop = prop.defaults;
		} while (prop != null);
		return Collections.enumeration(s);
	}

	/**
	 * Writes the key/value pairs to the given print stream.  They are
	 * written in the way described in the method store. This does not visit
	 * the keys in the default properties.
	 *
	 * @param out the stream, where the key/value pairs are written to
	 * @throws ClassCastException if this property contains any key or
	 *         value that isn't a string
	 * @see #store(OutputStream, String)
	 */
	public void list(PrintStream out) {
		Iterator iter = entrySet().iterator();
		int i = size();
		StringBuffer s = new StringBuffer(); // Reuse the same buffer.
		while (--i >= 0) {
			Map.Entry entry = (Map.Entry) iter.next();
			formatForOutput((String) entry.getKey(), s, true);
			s.append('=');
			formatForOutput((String) entry.getValue(), s, false);
			out.println(s);
		}
	}

	/**
	 * Writes the key/value pairs to the given print writer.  They are
	 * written in the way, described in the method store.
	 *
	 * @param out the writer, where the key/value pairs are written to
	 * @throws ClassCastException if this property contains any key or
	 *         value that isn't a string
	 * @see #store(OutputStream, String)
	 * @see #list(PrintStream)
	 * @since 1.1
	 */
	public void list(PrintWriter out) {
		Iterator iter = entrySet().iterator();
		int i = size();
		StringBuffer s = new StringBuffer(); // Reuse the same buffer.
		while (--i >= 0) {
			Map.Entry entry = (Map.Entry) iter.next();
			formatForOutput((String) entry.getKey(), s, true);
			s.append('=');
			formatForOutput((String) entry.getValue(), s, false);
			out.println(s);
		}
	}

	/**
	 * Formats a key or value for output in a properties file.
	 * See store for a description of the format.
	 *
	 * @param str the string to format
	 * @param buffer the buffer to add it to
	 * @param key true if all ' ' must be escaped for the key, false if only
	 *        leading spaces must be escaped for the value
	 * @see #store(OutputStream, String)
	 */
	private void formatForOutput(String str, StringBuffer buffer, boolean key) {
		if (key) {
			buffer.setLength(0);
			buffer.ensureCapacity(str.length());
		} else
			buffer.ensureCapacity(buffer.length() + str.length());
		boolean head = true;
		int size = str.length();
		for (int i = 0; i < size; i++) {
			char c = str.charAt(i);
			switch (c) {
				case '\n' :
					buffer.append("\\n");
					break;
				case '\r' :
					buffer.append("\\r");
					break;
				case '\t' :
					buffer.append("\\t");
					break;
				case ' ' :
					buffer.append(head ? "\\ " : " ");
					break;
				case '\\' :
				case '!' :
				case '#' :
				case '=' :
				case ':' :
					buffer.append('\\').append(c);
					break;
				default :
					if (c < ' ' || c > '~') {
						String hex = Integer.toHexString(c);
						buffer.append("\\u0000".substring(0, 6 - hex.length()));
						buffer.append(hex);
					} else
						buffer.append(c);
			}
			if (c != ' ')
				head = key;
		}
	}
} // class Properties