There are two separate trees of preference nodes, one for user preferences and one for system preferences. Each user has a separate user preference tree, and all users in a given system share the same system preference tree. The precise description of "user" and "system" will vary from implementation to implementation. Typical information stored in the user preference tree might include font choice, color choice, or preferred window location and size for a particular application. Typical information stored in the system preference tree might include installation configuration data for an application.
Nodes in a preference tree are named in a similar fashion to directories in a hierarchical file system. Every node in a preference tree has a node name (which is not necessarily unique), a unique absolute path name, and a path name relative to each ancestor including itself.
The root node has a node name of the empty string (""). Every other node has an arbitrary node name, specified at the time it is created. The only restrictions on this name are that it cannot be the empty string, and it cannot contain the slash character ('/').
The root node has an absolute path name of "/". Children of
the root node have absolute path names of "/" + <node
name>. All other nodes have absolute path names of <parent's
absolute path name>+ "/" + <node name>.
Note that all absolute path names begin with the slash character.
A node n's path name relative to its ancestor a is simply the string that must be appended to a's absolute path name in order to form n's absolute path name, with the initial slash character (if present) removed. Note that:
Note finally that:
All of the methods that modify preferences data are permitted to operate
asynchronously; they may return immediately, and changes will eventually
propagate to the persistent backing store with an implementation-dependent
delay. The flush method may be used to synchronously force
updates to the backing store. Normal termination of the Java Virtual
Machine will not result in the loss of pending updates -- an explicit
flush invocation is not required upon termination to ensure
that pending updates are made persistent.
All of the methods that read preferences from a Preferences
object require the invoker to provide a default value. The default value is
returned if no value has been previously set or if the backing store is
unavailable. The intent is to allow applications to operate, albeit
with slightly degraded functionality, even if the backing store becomes
unavailable. Several methods, like flush, have semantics that
prevent them from operating if the backing store is unavailable. Ordinary
applications should have no need to invoke any of these methods, which can
be identified by the fact that they are declared to throw BackingStoreException.
The methods in this class may be invoked concurrently by multiple threads in a single JVM without the need for external synchronization, and the results will be equivalent to some serial execution. If this class is used concurrently by multiple JVMs that store their preference data in the same backing store, the data store will not be corrupted, but no other guarantees are made concerning the consistency of the preference data.
This class contains an export/import facility, allowing preferences to be "exported" to an XML document, and XML documents representing preferences to be "imported" back into the system. This facility may be used to back up all or part of a preference tree, and subsequently restore from the backup.
The XML document has the following DOCTYPE declaration:
<!DOCTYPE preferences SYSTEM "http://java.sun.com/dtd/preferences.dtd">
<?xml version="1.0" encoding="UTF-8"?>
<!-- DTD for a Preferences tree. -->
<!-- The preferences element is at the root of an XML document
representing a Preferences tree. -->
<!ELEMENT preferences (root)>
<!-- The preferences element contains an optional version attribute,
which specifies version of DTD. -->
<!ATTLIST preferences EXTERNAL_XML_VERSION CDATA "0.0" >
<!-- The root element has a map representing the root's preferences
(if any), and one node for each child of the root (if any). -->
<!ELEMENT root (map, node*) >
<!-- Additionally, the root contains a type attribute, which
specifies whether it's the system or user root. -->
<!ATTLIST root
type (system|user) #REQUIRED >
<!-- Each node has a map representing its preferences (if any),
and one node for each child (if any). -->
<!ELEMENT node (map, node*) >
<!-- Additionally, each node has a name attribute -->
<!ATTLIST node
name CDATA #REQUIRED >
<!-- A map represents the preferences stored at a node (if any). -->
<!ELEMENT map (entry*) >
<!-- An entry represents a single preference, which is simply
a key-value pair. -->
<!ELEMENT entry EMPTY >
<!ATTLIST entry
key CDATA #REQUIRED
value CDATA #REQUIRED >
Preferences implementation must have an associated PreferencesFactory implementation. Every Java(TM) SE implementation must provide
some means of specifying which PreferencesFactory implementation
is used to generate the root preferences nodes. This allows the
administrator to replace the default preferences implementation with an
alternative implementation.
Implementation Note
The PreferencesFactory implementation is located as follows:
If the system property
java.util.prefs.PreferencesFactory is defined, then it is
taken to be the fully-qualified name of a class implementing the
PreferencesFactory interface. The class is loaded and
instantiated; if this process fails then an unspecified error is
thrown.
If a PreferencesFactory implementation class file
has been installed in a jar file that is visible to the
system class loader,
and that jar file contains a provider-configuration file named
java.util.prefs.PreferencesFactory in the resource
directory META-INF/services, then the first class name
specified in that file is taken. If more than one such jar file is
provided, the first one found will be used. The class is loaded
and instantiated; if this process fails then an unspecified error
is thrown.
Finally, if neither the above-mentioned system property nor
an extension jar file is provided, then the system-wide default
PreferencesFactory implementation for the underlying
platform is loaded and instantiated.
| Modifier and Type | Field and Description |
|---|---|
| private static final PreferencesFactory | |
| public static final int | MAX_KEY_LENGTH
Maximum length of string allowed as a key (80 characters). |
| public static final int | MAX_NAME_LENGTH
Maximum length of a node name (80 characters). |
| public static final int | MAX_VALUE_LENGTH
Maximum length of string allowed as a value (8192 characters). |
| Access | Constructor and Description |
|---|---|
| protected |
| Modifier and Type | Method and Description |
|---|---|
| public abstract String | Returns: this preference node's absolute path name.Returns this preference node's absolute path name. |
| public abstract void | addNodeChangeListener(NodeChangeListener
The ncl)NodeChangeListener to add.Registers the specified listener to receive node change events for this node. |
| public abstract void | addPreferenceChangeListener(PreferenceChangeListener
The preference change listener to add. pcl)Registers the specified listener to receive preference change events for this preference node. |
| public abstract String[] | Returns: the names of the children of this preference node.Returns the names of the children of this preference node, relative to this node. |
| public abstract void | |
| public abstract void | exportNode(OutputStream
the output stream on which to emit the XML document. os)Emits on the specified output stream an XML document representing all of the preferences contained in this node (but not its descendants). |
| public abstract void | exportSubtree(OutputStream
the output stream on which to emit the XML document. os)Emits an XML document representing all of the preferences contained in this node and all of its descendants. |
| private static PreferencesFactory | |
| public abstract void | flush()
Forces any changes in the contents of this preference node and its descendants to the persistent store. |
| public abstract String | Returns: the value associated withkey, or def
if no value is associated with key, or the backing
store is inaccessible.key whose associated value is to be returned. key, String the value to be returned in the event that this
preference node has no value associated with def)key.Returns the value associated with the specified key in this preference node. |
| public abstract boolean | Returns: the boolean value represented by the string associated withkey in this preference node, or def if the
associated value does not exist or cannot be interpreted as
a boolean.key whose associated value is to be returned as a boolean. key, boolean the value to be returned in the event that this
preference node has no value associated with def)key
or the associated value cannot be interpreted as a boolean,
or the backing store is inaccessible.Returns the boolean value represented by the string associated with the specified key in this preference node. |
| public abstract byte[] | Returns: the byte array value represented by the string associated withkey in this preference node, or def if the
associated value does not exist or cannot be interpreted as
a byte array.key whose associated value is to be returned as a byte array. key, byte[] the value to be returned in the event that this
preference node has no value associated with def)key
or the associated value cannot be interpreted as a byte array,
or the backing store is inaccessible.Returns the byte array value represented by the string associated with the specified key in this preference node. |
| public abstract double | Returns: the double value represented by the string associated withkey in this preference node, or def if the
associated value does not exist or cannot be interpreted as
a double.key whose associated value is to be returned as a double. key, double the value to be returned in the event that this
preference node has no value associated with def)key
or the associated value cannot be interpreted as a double,
or the backing store is inaccessible.Returns the double value represented by the string associated with the specified key in this preference node. |
| public abstract float | Returns: the float value represented by the string associated withkey in this preference node, or def if the
associated value does not exist or cannot be interpreted as
a float.key whose associated value is to be returned as a float. key, float the value to be returned in the event that this
preference node has no value associated with def)key
or the associated value cannot be interpreted as a float,
or the backing store is inaccessible.Returns the float value represented by the string associated with the specified key in this preference node. |
| public abstract int | Returns: the int value represented by the string associated withkey in this preference node, or def if the
associated value does not exist or cannot be interpreted as
an int.key whose associated value is to be returned as an int. key, int the value to be returned in the event that this
preference node has no value associated with def)key
or the associated value cannot be interpreted as an int,
or the backing store is inaccessible.Returns the int value represented by the string associated with the specified key in this preference node. |
| public abstract long | Returns: the long value represented by the string associated withkey in this preference node, or def if the
associated value does not exist or cannot be interpreted as
a long.key whose associated value is to be returned as a long. key, long the value to be returned in the event that this
preference node has no value associated with def)key
or the associated value cannot be interpreted as a long,
or the backing store is inaccessible.Returns the long value represented by the string associated with the specified key in this preference node. |
| public static void | importPreferences(InputStream
the input stream from which to read the XML document. is)Imports all of the preferences represented by the XML document on the specified input stream. |
| public abstract boolean | Returns: true if this preference node is in the user
preference tree, false if it's in the system
preference tree.Returns |
| public abstract String[] | Returns: an array of the keys that have an associated value in this preference node.Returns all of the keys that have an associated value in this preference node. |
| public abstract String | Returns: this preference node's name, relative to its parent.Returns this preference node's name, relative to its parent. |
| public abstract Preferences | |
| public abstract boolean | Returns: true if the specified node exists.the path name of the node whose existence
is to be checked. pathName)Returns true if the named preference node exists in the same tree as this node. |
| private static String | |
| public abstract Preferences | Returns: the parent of this preference node.Returns the parent of this preference node, or |
| public abstract void | |
| public abstract void | putBoolean(String
key with which the string form of value is to be associated. key, boolean value whose string form is to be associated with key. value)Associates a string representing the specified boolean value with the specified key in this preference node. |
| public abstract void | putByteArray(String
key with which the string form of value is to be associated. key, byte[] value whose string form is to be associated with key. value)Associates a string representing the specified byte array with the specified key in this preference node. |
| public abstract void | |
| public abstract void | |
| public abstract void | |
| public abstract void | |
| public abstract void | |
| public abstract void | removeNode()
Removes this preference node and all of its descendants, invalidating any preferences contained in the removed nodes. |
| public abstract void | removeNodeChangeListener(NodeChangeListener
The ncl)NodeChangeListener to remove.Removes the specified |
| public abstract void | removePreferenceChangeListener(PreferenceChangeListener
The preference change listener to remove. pcl)Removes the specified preference change listener, so it no longer receives preference change events. |
| public abstract void | sync()
Ensures that future reads from this preference node and its
descendants reflect any changes that were committed to the persistent
store (from any VM) prior to the |
| public static Preferences | Returns: the system preference node associated with the package of whichc is a member.the class for whose package a system preference node is desired. c)Returns the preference node from the system preference tree that is associated (by convention) with the specified class's package. |
| public static Preferences | Returns: the root preference node for the system.Returns the root preference node for the system. |
| public abstract String | toString()
Overrides java. Returns a string representation of this preferences node,
as if computed by the expression: |
| public static Preferences | Returns: the user preference node associated with the package of whichc is a member.the class for whose package a user preference node is desired. c)Returns the preference node from the calling user's preference tree that is associated (by convention) with the specified class's package. |
| public static Preferences | Returns: the root preference node for the calling user.Returns the root preference node for the calling user. |
| factory | back to summary |
|---|---|
| private static final PreferencesFactory factory | |
| MAX_KEY_LENGTH | back to summary |
|---|---|
| public static final int MAX_KEY_LENGTH Maximum length of string allowed as a key (80 characters). | |
| MAX_NAME_LENGTH | back to summary |
|---|---|
| public static final int MAX_NAME_LENGTH Maximum length of a node name (80 characters). | |
| MAX_VALUE_LENGTH | back to summary |
|---|---|
| public static final int MAX_VALUE_LENGTH Maximum length of string allowed as a value (8192 characters). | |
| Preferences | back to summary |
|---|---|
| protected Preferences() Sole constructor. (For invocation by subclass constructors, typically implicit.) | |
| absolutePath | back to summary |
|---|---|
| public abstract String absolutePath() Returns this preference node's absolute path name.
| |
| addNodeChangeListener | back to summary |
|---|---|
| public abstract void addNodeChangeListener(NodeChangeListener ncl) Registers the specified listener to receive node change events
for this node. A node change event is generated when a child node is
added to or removed from this node. (A single Events are only guaranteed for changes made within the same JVM as the registered listener, though some implementations may generate events for changes made outside this JVM. Events may be generated before the changes have become permanent. Events are not generated when indirect descendants of this node are added or removed; a caller desiring such events must register with each descendant. Few guarantees can be made regarding node creation. Because nodes are created implicitly upon access, it may not be feasible for an implementation to determine whether a child node existed in the backing store prior to access (for example, because the backing store is unreachable or cached information is out of date). Under these circumstances, implementations are neither required to generate node change events nor prohibited from doing so.
| |
| addPreferenceChangeListener | back to summary |
|---|---|
| public abstract void addPreferenceChangeListener(PreferenceChangeListener pcl) Registers the specified listener to receive preference change
events for this preference node. A preference change event is
generated when a preference is added to this node, removed from this
node, or when the value associated with a preference is changed.
(Preference change events are not generated by the Events are only guaranteed for changes made within the same JVM as the registered listener, though some implementations may generate events for changes made outside this JVM. Events may be generated before the changes have been made persistent. Events are not generated when preferences are modified in descendants of this node; a caller desiring such events must register with each descendant.
| |
| childrenNames | back to summary |
|---|---|
| public abstract String[] childrenNames() throws BackingStoreException Returns the names of the children of this preference node, relative to this node. (The returned array will be of size zero if this node has no children.)
| |
| clear | back to summary |
|---|---|
| public abstract void clear() throws BackingStoreException Removes all of the preferences (key-value associations) in this preference node. This call has no effect on any descendants of this node. If this implementation supports stored defaults, and this
node in the preferences hierarchy contains any such defaults,
the stored defaults will be "exposed" by this call, in the sense that
they will be returned by succeeding calls to
| |
| exportNode | back to summary |
|---|---|
| public abstract void exportNode(OutputStream os) throws IOException, BackingStoreException Emits on the specified output stream an XML document representing all of the preferences contained in this node (but not its descendants). This XML document is, in effect, an offline backup of the node. The XML document will have the following DOCTYPE declaration: This method is an exception to the general rule that the results of concurrently executing multiple methods in this class yields results equivalent to some serial execution. If the preferences at this node are modified concurrently with an invocation of this method, the exported preferences comprise a "fuzzy snapshot" of the preferences contained in the node; some of the concurrent modifications may be reflected in the exported data while others may not.
| |
| exportSubtree | back to summary |
|---|---|
| public abstract void exportSubtree(OutputStream os) throws IOException, BackingStoreException Emits an XML document representing all of the preferences contained in this node and all of its descendants. This XML document is, in effect, an offline backup of the subtree rooted at the node. The XML document will have the following DOCTYPE declaration: This method is an exception to the general rule that the results of concurrently executing multiple methods in this class yields results equivalent to some serial execution. If the preferences or nodes in the subtree rooted at this node are modified concurrently with an invocation of this method, the exported preferences comprise a "fuzzy snapshot" of the subtree; some of the concurrent modifications may be reflected in the exported data while others may not.
| |
| factory | back to summary |
|---|---|
| private static PreferencesFactory factory() | |
| flush | back to summary |
|---|---|
| public abstract void flush() throws BackingStoreException Forces any changes in the contents of this preference node and its descendants to the persistent store. Once this method returns successfully, it is safe to assume that all changes made in the subtree rooted at this node prior to the method invocation have become permanent. Implementations are free to flush changes into the persistent store at any time. They do not need to wait for this method to be called. When a flush occurs on a newly created node, it is made persistent, as are any ancestors (and descendants) that have yet to be made persistent. Note however that any preference value changes in ancestors are not guaranteed to be made persistent. If this method is invoked on a node that has been removed with
the
| |
| get | back to summary |
|---|---|
| public abstract String get(String key, String def) Returns the value associated with the specified key in this preference node. Returns the specified default if there is no value associated with the key, or the backing store is inaccessible. Some implementations may store default values in their backing stores. If there is no value associated with the specified key but there is such a stored default, it is returned in preference to the specified default.
| |
| getBoolean | back to summary |
|---|---|
| public abstract boolean getBoolean(String key, boolean def) Returns the boolean value represented by the string associated with the
specified key in this preference node. Valid strings
are Returns the specified default if there is no value
associated with the key, the backing store is inaccessible, or if the
associated value is something other than If the implementation supports stored defaults and such a
default exists and is accessible, it is used in preference to the
specified default, unless the stored default is something other than
| |
| getByteArray | back to summary |
|---|---|
| public abstract byte[] getByteArray(String key, byte[] def) Returns the byte array value represented by the string associated with
the specified key in this preference node. Valid strings are
Base64 encoded binary data, as defined in RFC 2045, Section 6.8,
with one minor change: the string must consist solely of characters
from the Base64 Alphabet; no newline characters or
extraneous characters are permitted. This method is intended for use
in conjunction with Returns the specified default if there is no value associated with the key, the backing store is inaccessible, or if the associated value is not a valid Base64 encoded byte array (as defined above). If the implementation supports stored defaults and such a default exists and is accessible, it is used in preference to the specified default, unless the stored default is not a valid Base64 encoded byte array (as defined above), in which case the specified default is used.
| |
| getDouble | back to summary |
|---|---|
| public abstract double getDouble(String key, double def) Returns the double value represented by the string associated with the
specified key in this preference node. The string is converted to an
integer as by If the implementation supports stored defaults and such a
default exists, is accessible, and could be converted to a double
with
| |
| getFloat | back to summary |
|---|---|
| public abstract float getFloat(String key, float def) Returns the float value represented by the string associated with the
specified key in this preference node. The string is converted to an
integer as by If the implementation supports stored defaults and such a
default exists, is accessible, and could be converted to a float
with
| |
| getInt | back to summary |
|---|---|
| public abstract int getInt(String key, int def) Returns the int value represented by the string associated with the
specified key in this preference node. The string is converted to
an integer as by If the implementation supports stored defaults and such a
default exists, is accessible, and could be converted to an int
with
| |
| getLong | back to summary |
|---|---|
| public abstract long getLong(String key, long def) Returns the long value represented by the string associated with the
specified key in this preference node. The string is converted to
a long as by If the implementation supports stored defaults and such a
default exists, is accessible, and could be converted to a long
with
| |
| importPreferences | back to summary |
|---|---|
| public static void importPreferences(InputStream is) throws IOException, InvalidPreferencesFormatException Imports all of the preferences represented by the XML document on the specified input stream. The document may represent user preferences or system preferences. If it represents user preferences, the preferences will be imported into the calling user's preference tree (even if they originally came from a different user's preference tree). If any of the preferences described by the document inhabit preference nodes that do not exist, the nodes will be created. The XML document must have the following DOCTYPE declaration: exportNode(OutputStream) and
exportSubtree(OutputStream).
This method is an exception to the general rule that the results of
concurrently executing multiple methods in this class yields
results equivalent to some serial execution. The method behaves
as if implemented on top of the other public methods in this class,
notably
| |
| isUserNode | back to summary |
|---|---|
| public abstract boolean isUserNode() Returns
| |
| keys | back to summary |
|---|---|
| public abstract String[] keys() throws BackingStoreException Returns all of the keys that have an associated value in this preference node. (The returned array will be of size zero if this node has no preferences.) If the implementation supports stored defaults and there are any such defaults at this node that have not been overridden, by explicit preferences, the defaults are returned in the array in addition to any explicit preferences.
| |
| name | back to summary |
|---|---|
| public abstract String name() Returns this preference node's name, relative to its parent.
| |
| node | back to summary |
|---|---|
| public abstract Preferences node(String pathName) Returns the named preference node in the same tree as this node,
creating it and any of its ancestors if they do not already exist.
Accepts a relative or absolute path name. Relative path names
(which do not begin with the slash character If the returned node did not exist prior to this call, this node and
any ancestors that were created by this call are not guaranteed
to become permanent until the
| |
| nodeExists | back to summary |
|---|---|
| public abstract boolean nodeExists(String pathName) throws BackingStoreException Returns true if the named preference node exists in the same tree
as this node. Relative path names (which do not begin with the slash
character If this node (or an ancestor) has already been removed with the
| |
| nodeName | back to summary |
|---|---|
| private static String nodeName(Class<?> c) Returns the absolute path name of the node corresponding to the package of the specified object.
| |
| parent | back to summary |
|---|---|
| public abstract Preferences parent() Returns the parent of this preference node, or
| |
| put | back to summary |
|---|---|
| public abstract void put(String key, String value) Associates the specified value with the specified key in this preference node.
| |
| putBoolean | back to summary |
|---|---|
| public abstract void putBoolean(String key, boolean value) Associates a string representing the specified boolean value with the
specified key in this preference node. The associated string is
| |
| putByteArray | back to summary |
|---|---|
| public abstract void putByteArray(String key, byte[] value) Associates a string representing the specified byte array with the
specified key in this preference node. The associated string is
the Base64 encoding of the byte array, as defined in RFC 2045, Section 6.8,
with one minor change: the string will consist solely of characters
from the Base64 Alphabet; it will not contain any newline
characters. Note that the maximum length of the byte array is limited
to three quarters of
| |
| putDouble | back to summary |
|---|---|
| public abstract void putDouble(String key, double value) Associates a string representing the specified double value with the
specified key in this preference node. The associated string is the
one that would be returned if the double value were passed to
| |
| putFloat | back to summary |
|---|---|
| public abstract void putFloat(String key, float value) Associates a string representing the specified float value with the
specified key in this preference node. The associated string is the
one that would be returned if the float value were passed to
| |
| putInt | back to summary |
|---|---|
| public abstract void putInt(String key, int value) Associates a string representing the specified int value with the
specified key in this preference node. The associated string is the
one that would be returned if the int value were passed to
| |
| putLong | back to summary |
|---|---|
| public abstract void putLong(String key, long value) Associates a string representing the specified long value with the
specified key in this preference node. The associated string is the
one that would be returned if the long value were passed to
| |
| remove | back to summary |
|---|---|
| public abstract void remove(String key) Removes the value associated with the specified key in this preference node, if any. If this implementation supports stored defaults, and there is
such a default for the specified preference, the stored default will be
"exposed" by this call, in the sense that it will be returned
by a succeeding call to
| |
| removeNode | back to summary |
|---|---|
| public abstract void removeNode() throws BackingStoreException Removes this preference node and all of its descendants, invalidating
any preferences contained in the removed nodes. Once a node has been
removed, attempting any method other than The removal is not guaranteed to be persistent until the
If this implementation supports stored defaults, removing a
node exposes any stored defaults at or below this node. Thus, a
subsequent call to
| |
| removeNodeChangeListener | back to summary |
|---|---|
| public abstract void removeNodeChangeListener(NodeChangeListener ncl) Removes the specified
| |
| removePreferenceChangeListener | back to summary |
|---|---|
| public abstract void removePreferenceChangeListener(PreferenceChangeListener pcl) Removes the specified preference change listener, so it no longer receives preference change events.
| |
| sync | back to summary |
|---|---|
| public abstract void sync() throws BackingStoreException Ensures that future reads from this preference node and its
descendants reflect any changes that were committed to the persistent
store (from any VM) prior to the
| |
| systemNodeForPackage | back to summary |
|---|---|
| public static Preferences systemNodeForPackage(Class<?> c) Returns the preference node from the system preference tree that is
associated (by convention) with the specified class's package. The
convention is as follows: the absolute path name of the node is the
fully qualified package name, preceded by a slash ( This convention does not apply to the unnamed package, whose
associated preference node is A class static Preferences prefs = Preferences.systemNodeForPackage(Foo.class);This idiom obviates the need for using a string to describe the preferences node and decreases the likelihood of a run-time failure. (If the class name is misspelled, it will typically result in a compile-time error.) Invoking this method will result in the creation of the returned
node and its ancestors if they do not already exist. If the returned
node did not exist prior to this call, this node and any ancestors that
were created by this call are not guaranteed to become permanent until
the
| |
| systemRoot | back to summary |
|---|---|
| public static Preferences systemRoot() Returns the root preference node for the system.
| |
| toString | back to summary |
|---|---|
| public abstract String toString() Overrides java. Returns a string representation of this preferences node,
as if computed by the expression: | |
| userNodeForPackage | back to summary |
|---|---|
| public static Preferences userNodeForPackage(Class<?> c) Returns the preference node from the calling user's preference tree
that is associated (by convention) with the specified class's package.
The convention is as follows: the absolute path name of the node is the
fully qualified package name, preceded by a slash ( This convention does not apply to the unnamed package, whose
associated preference node is A class static Preferences prefs = Preferences.userNodeForPackage(Foo.class);This idiom obviates the need for using a string to describe the preferences node and decreases the likelihood of a run-time failure. (If the class name is misspelled, it will typically result in a compile-time error.) Invoking this method will result in the creation of the returned
node and its ancestors if they do not already exist. If the returned
node did not exist prior to this call, this node and any ancestors that
were created by this call are not guaranteed to become permanent until
the
| |
| userRoot | back to summary |
|---|---|
| public static Preferences userRoot() Returns the root preference node for the calling user.
| |