AbstractPreferences (Java Platform SE 8 )

java.lang.Object
- java.util.prefs.Preferences
- - java.util.prefs.AbstractPreferences

```
public abstract class AbstractPreferences
extends Preferences
```
这个类提供了一个框架实现的 Preferences班，大大缓解了执行的任务。
这类是Preferences者只。Preferences设施的正常用户不需要咨询文件。的Preferences文档应该足够了。

实施者必须超越九摘要服务提供者接口（SPI）方法：getSpi(String)，putSpi(String,String)，removeSpi(String)，childSpi(String)，removeNodeSpi()，keysSpi()，childrenNamesSpi()，syncSpi()和flushSpi()。所有的具体方法精确地说明他们是如何实现在SPI的方法。实现者可以在他的自由裁量权，覆盖一个或一个以上的具体方法，如果默认的实现是任何原因不满意，如性能。

SPI的方法分为三组关于异常行为。的getSpi方法不应该抛出异常，但这并不重要，因为任何例外的方法抛出将截获的get(String,String)，它会返回给调用者指定的默认值。的removeNodeSpi, keysSpi, childrenNamesSpi, syncSpi和flushSpi方法指定扔BackingStoreException，及实施要求无法执行操作抛出这个异常。异常向外传播，导致相应的“失败”方法失败。

剩下的SPI方法putSpi(String,String)，removeSpi(String)和childSpi(String)具有更复杂的异常行为。他们都没有指定，把BackingStoreException，他们一般都能遵守合同即使后备存储不可用。这是真的因为他们不会返回任何信息，其效果并不需要等到随后调用Preferences.flush()或Preferences.sync()成为永久。一般来说，这些SPI方法不应该抛出异常。在一些实现中，有可能的情况下，这些电话甚至不能入队请求的操作后处理。即使在这种情况下，也可以简单地忽略调用和返回，而不是抛出一个异常。在这种情况下，然而，对flush()和sync所有后续调用返回false，返回true意味着以前所有的操作已成功地成为永久性的。

有一种情况下，putSpi, removeSpi and childSpi应该抛出一个例外：如果对方没有足够的权限对底层操作系统执行所请求的操作。例如，这将发生在大多数系统上，如果一个非特权的用户试图修改系统的偏好。（所需的权限将从实现到实现有所不同。在某些实现中，它们是修改文件系统中某个目录的内容的权利；其他的则是在任何情况下修改注册表中某个键的内容的权利。）在任何一种情况下，让程序继续执行，就好像这些操作在以后会变成永久性的一样。虽然在这种情况下，实现不需要抛出一个异常，但他们被鼓励这样做。一个SecurityException是合适的。

大部分的SPI方法需要执行读或写在一个偏好节点信息。实现者应该注意的事实，另一个虚拟机可以同时删除该节点从存储支持。它是实施的责任重新创建节点，如果它已被删除。

注：在实施Preferences太阳的默认实现，用户的身份从底层的操作系统继承并不会改变虚拟机的寿命。这是公认的，服务器端Preferences实现可能有用户身份变更请求，含蓄地传递Preferences方法通过静态ThreadLocal使用实例。这样的实现作者强烈地鼓励确定访问的时间偏好的用户（例如由get(String,String)或put(String,String)法）而不是永久关联的用户每个Preferences实例。后者的行为冲突与正常Preferences使用会导致很大的混乱。

从以下版本开始：

一点四

另请参见：

Preferences

Field Summary

Fields
Modifier and Type	Field and Description
`protected Object`	`lock` 一个对象，其监视器用于锁定此节点。
`protected boolean`	`newNode` 这场应该 `true`如果这个节点没有对该对象的创建之前备份存储的存在。

Fields inherited from class java.util.prefs.Preferences
MAX_KEY_LENGTH, MAX_NAME_LENGTH, MAX_VALUE_LENGTH

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`AbstractPreferences(AbstractPreferences parent, String name)` 使用指定的父节点和指定的名称与指定的父节点创建一个首选节点。

方法摘要

所有方法接口方法抽象方法具体的方法
Modifier and Type	Method and Description
`String`	`absolutePath()` 实现了 `absolutePath`方法按规范 `Preferences.absolutePath()`。
`void`	`addNodeChangeListener(NodeChangeListener ncl)` 寄存器指定监听器接收节点变化事件此节点。
`void`	`addPreferenceChangeListener(PreferenceChangeListener pcl)` 寄存器指定监听器接收偏好变化事件这种偏好结。
`protected AbstractPreferences[]`	`cachedChildren()` 返回此节点的所有已知的初始的孩子。
`String[]`	`childrenNames()` 实现了 `children`方法按规范 `Preferences.childrenNames()`。
`protected abstract String[]`	`childrenNamesSpi()` 返回此首选节点的子节点的名称。
`protected abstract AbstractPreferences`	`childSpi(String name)` 返回此首选节点的命名子节点，如果它不已经存在，则创建它。
`void`	`clear()` 实现了 `clear`方法按规范 `Preferences.clear()`。
`void`	`exportNode(OutputStream os)` 实现了 `exportNode`方法按规范 `Preferences.exportNode(OutputStream)`。
`void`	`exportSubtree(OutputStream os)` 实现了 `exportSubtree`方法按规范 `Preferences.exportSubtree(OutputStream)`。
`void`	`flush()` 实现了 `flush`方法按规范 `Preferences.flush()`。
`protected abstract void`	`flushSpi()` 此方法被调用此节点锁定。
`String`	`get(String key, String def)` 实现了 `get`方法按规范 `Preferences.get(String,String)`。
`boolean`	`getBoolean(String key, boolean def)` 实现了 `getBoolean`方法按规范 `Preferences.getBoolean(String,boolean)`。
`byte[]`	`getByteArray(String key, byte[] def)` 实现了 `getByteArray`方法按规范 `Preferences.getByteArray(String,byte[])`。
`protected AbstractPreferences`	`getChild(String nodeName)` 返回指定的孩子，如果它存在，或 `null`如果不。
`double`	`getDouble(String key, double def)` 实现了 `getDouble`方法按规范 `Preferences.getDouble(String,double)`。
`float`	`getFloat(String key, float def)` 实现了 `getFloat`方法按规范 `Preferences.getFloat(String,float)`。
`int`	`getInt(String key, int def)` 实现了 `getInt`方法按规范 `Preferences.getInt(String,int)`。
`long`	`getLong(String key, long def)` 实现了 `getLong`方法按规范 `Preferences.getLong(String,long)`。
`protected abstract String`	`getSpi(String key)` 返回与指定的键在这个偏好节点关联的值，或 `null`如果没有协会或协会这一关键，此时无法确定。
`protected boolean`	`isRemoved()` 返回 `true`敌我识别这个节点（或祖先）已与 `removeNode()`法去除。
`boolean`	`isUserNode()` 实现了 `isUserNode`方法按规范 `Preferences.isUserNode()`。
`String[]`	`keys()` 实现了 `keys`方法按规范 `Preferences.keys()`。
`protected abstract String[]`	`keysSpi()` 返回在这个首选项节点中有关联的值的所有键。
`String`	`name()` 实现了 `name`方法按规范 `Preferences.name()`。
`Preferences`	`node(String path)` 实现了 `node`方法按规范 `Preferences.node(String)`。
`boolean`	`nodeExists(String path)` 实现了 `nodeExists`方法按规范 `Preferences.nodeExists(String)`。
`Preferences`	`parent()` 实现了 `parent`方法按规范 `Preferences.parent()`。
`void`	`put(String key, String value)` 实现了 `put`方法按规范 `Preferences.put(String,String)`。
`void`	`putBoolean(String key, boolean value)` 实现了 `putBoolean`方法按规范 `Preferences.putBoolean(String,boolean)`。
`void`	`putByteArray(String key, byte[] value)` 实现了 `putByteArray`方法按规范 `Preferences.putByteArray(String,byte[])`。
`void`	`putDouble(String key, double value)` 实现了 `putDouble`方法按规范 `Preferences.putDouble(String,double)`。
`void`	`putFloat(String key, float value)` 实现了 `putFloat`方法按规范 `Preferences.putFloat(String,float)`。
`void`	`putInt(String key, int value)` 实现了 `putInt`方法按规范 `Preferences.putInt(String,int)`。
`void`	`putLong(String key, long value)` 实现了 `putLong`方法按规范 `Preferences.putLong(String,long)`。
`protected abstract void`	`putSpi(String key, String value)` 将给定的键值关联到这个首选节点上。
`void`	`remove(String key)` 实现了 `remove(String)`方法按规范 `Preferences.remove(String)`。
`void`	`removeNode()` 实现了 `removeNode()`方法按规范 `Preferences.removeNode()`。
`void`	`removeNodeChangeListener(NodeChangeListener ncl)` 移除指定的 `NodeChangeListener`，所以它不再接受变更事件。
`protected abstract void`	`removeNodeSpi()` 消除这种偏好的节点，它失效，它包含任何偏好。
`void`	`removePreferenceChangeListener(PreferenceChangeListener pcl)` 移除指定的偏好更改侦听器，所以它不再接收偏好更改事件。
`protected abstract void`	`removeSpi(String key)` 删除此首选项节点中指定的键的关联（如果有的话）。
`void`	`sync()` 实现了 `sync`方法按规范 `Preferences.sync()`。
`protected abstract void`	`syncSpi()` 此方法被调用此节点锁定。
`String`	`toString()` 返回此首选项节点的绝对路径名称。

Methods inherited from class java.util.prefs.Preferences
importPreferences, systemNodeForPackage, systemRoot, userNodeForPackage, userRoot

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - newNode
```
protected boolean newNode
```
    这场应该 true如果这个节点没有对该对象的创建之前备份存储的存在。字段被初始化为假，但可能被设置为真的一个子类的构造函数（不应该被修改）。此字段指示在创建完成时是否应该触发一个节点更改事件。
  - lock
```
protected final Object lock
```
    一个对象，其监视器用于锁定此节点。此对象被用于偏好的节点本身，以减少故意或无意的拒绝服务，由于一个锁定的节点的可能性。为了避免死锁，一个节点是从未由一个线程持有的锁锁上节点的子孙。
- Constructor Detail
  - AbstractPreferences
```
protected AbstractPreferences(AbstractPreferences parent,
                              String name)
```
    使用指定的父节点和指定的名称与指定的父节点创建一个首选节点。
    
    参数
    
    parent -这种偏好节点的父节点，或null，如果这根。
    
    name -这种偏好节点的名称，相对于它的父，或 ""如果这根。
    
    异常
    
    IllegalArgumentException -如果 name包含斜杠（ '/'），或 parent是 null和名字不是 ""。
- 方法详细信息
  - put
```
public void put(String key,
                String value)
```
    实现了 put方法按规范 Preferences.put(String,String)。
    实施检查，键和值都是合法的，得到这个优惠节点的锁，检查该节点没有被删除，调用putSpi(String,String)，如果有任何的偏好变化的听众，入队的通知事件处理的事件调度线程。
    
    Specified by:
    
    put 方法重写，继承类 Preferences
    
    参数
    
    key键与指定的值是相关联的。
    
    value值必须与指定键关联。
    
    异常
    
    NullPointerException如果键或值 null。
    
    IllegalArgumentException -如果 key.length()超过 MAX_KEY_LENGTH或者 value.length超过 MAX_VALUE_LENGTH。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
  - get
```
public String get(String key,
                  String def)
```
    实现了 get方法按规范 Preferences.get(String,String)。
    实现首先检查是否key是null扔NullPointerException如果是这样的话。然后得到这个优惠节点的锁，检查该节点没有被拆除，getSpi(String)调用，并返回结果，除非getSpi调用返回null或抛出一个异常，在这种情况下，这个调用返回def。
    
    Specified by:
    
    get 方法重写，继承类 Preferences
    
    参数
    
    key密钥的相关值被返回。
    
    def -是在事件，这种偏好节点没有与 key值返回的值。
    
    结果
    
    与 key的价值，或 def如果没有价值与 key。
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    NullPointerException如果关键是 null。（一 null默认是允许的。）
  - remove
```
public void remove(String key)
```
    实现了 remove(String)方法按规范
    这个实现得到这种偏好节点的锁，检查该节点没有被删除，调用removeSpi(String)如果有任何偏好改变监听器，入队的通知事件处理的事件调度线程。
    Preferences.remove(String)。
    
    Specified by:
    
    remove 方法重写，继承类 Preferences
    
    参数
    
    key键的映射是从偏好节点删除。
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    NullPointerException -如果 key是 null ..
  - clear
```
public void clear()
           throws BackingStoreException
```
    实现了 clear方法按规范 Preferences.clear()。
    这个实现得到这种偏好节点的锁，调用keys()获得键数组、遍历数组调用remove(String)每个关键。
    
    Specified by:
    
    clear 方法重写，继承类 Preferences
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    Preferences.removeNode()
  - putInt
```
public void putInt(String key,
                   int value)
```
    实现了 putInt方法按规范 Preferences.putInt(String,int)。
    这将value实施了一系列与Integer.toString(int)和调用put(String,String)结果。
    
    Specified by:
    
    putInt 方法重写，继承类 Preferences
    
    参数
    
    key键的值的字符串形式是相关的。
    
    value值的字符串形式是与关键。
    
    异常
    
    NullPointerException如果关键是 null。
    
    IllegalArgumentException -如果 key.length()超过 MAX_KEY_LENGTH。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    Preferences.getInt(String,int)
  - getInt
```
public int getInt(String key,
                  int def)
```
    实现了 getInt方法按规范 Preferences.getInt(String,int)。
    这get(key, null)实现调用。如果返回值为非零，实现试图将它与一个int Integer.parseInt(String)。如果尝试成功，则该方法返回返回值。否则，def返回。
    
    Specified by:
    
    getInt 方法重写，继承类 Preferences
    
    参数
    
    key键的值是int返回
    
    def -是在事件，这种偏好节点没有与 key或相关的价值不相关的值被解释为int返回值
    
    结果
    
    通过在这个节点 key偏好相关的字符串表示的int值，或 def如果关联的值不存在或不能被解释为一个int
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    如果是 null key NullPointerException。
    
    另请参见：
    
    Preferences.putInt(String,int)， Preferences.get(String,String)
  - putLong
```
public void putLong(String key,
                    long value)
```
    实现了 putLong方法按规范 Preferences.putLong(String,long)。
    这将value实施了一系列与Long.toString(long)和调用put(String,String)结果。
    
    Specified by:
    
    putLong 方法重写，继承类 Preferences
    
    参数
    
    key键的值的字符串形式是相关的。
    
    value值的字符串形式是与关键。
    
    异常
    
    NullPointerException如果关键是 null。
    
    IllegalArgumentException -如果 key.length()超过 MAX_KEY_LENGTH。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    Preferences.getLong(String,long)
  - getLong
```
public long getLong(String key,
                    long def)
```
    实现了 getLong方法按规范 Preferences.getLong(String,long)。
    这get(key, null)实现调用。如果返回值为非零，执行试图把它翻译成一个long与Long.parseLong(String)。如果尝试成功，则该方法返回返回值。否则，def返回。
    
    Specified by:
    
    getLong 方法重写，继承类 Preferences
    
    参数
    
    key键的值作为长回来。
    
    def -是在事件，这种偏好节点没有与 key或相关的价值不相关的值被解释为一个长的返回值。
    
    结果
    
    通过在这个节点 key偏好相关的字符串表示的值，或 def如果关联的值不存在或不能被解释为一个长。
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    如果是 null key NullPointerException。
    
    另请参见：
    
    Preferences.putLong(String,long)， Preferences.get(String,String)
  - putBoolean
```
public void putBoolean(String key,
                       boolean value)
```
    实现了 putBoolean方法按规范 Preferences.putBoolean(String,boolean)。
    这将value实施了一系列与String.valueOf(boolean)和调用put(String,String)结果。
    
    Specified by:
    
    putBoolean 方法重写，继承类 Preferences
    
    参数
    
    key键的值的字符串形式是相关的。
    
    value值的字符串形式是与关键。
    
    异常
    
    NullPointerException如果关键是 null。
    
    IllegalArgumentException -如果 key.length()超过 MAX_KEY_LENGTH。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    Preferences.getBoolean(String,boolean)， Preferences.get(String,String)
  - getBoolean
```
public boolean getBoolean(String key,
                          boolean def)
```
    实现了 getBoolean方法按规范
    这get(key, null)实现调用。如果返回值为非零，它与"true"使用String.equalsIgnoreCase(String)相比。如果比较的结果true，这个调用返回true。否则，原来的返回值与"false"，再次使用String.equalsIgnoreCase(String)。如果比较的结果true，这个调用返回false。否则，该调用返回def。
    Preferences.getBoolean(String,boolean)。
    
    Specified by:
    
    getBoolean 方法重写，继承类 Preferences
    
    参数
    
    key键的值是一个布尔返回。
    
    def -是在事件，这种偏好节点没有与 key或相关的价值不相关的值被解释为一个布尔函数的返回值。
    
    结果
    
    通过在这个节点 key偏好相关的字符串表示的布尔值，或 def如果关联的值不存在或不能被解释为一个布尔。
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    如果是 null key NullPointerException。
    
    另请参见：
    
    Preferences.get(String,String)， Preferences.putBoolean(String,boolean)
  - putFloat
```
public void putFloat(String key,
                     float value)
```
    实现了 putFloat方法按规范 Preferences.putFloat(String,float)。
    这将value实施了一系列与Float.toString(float)和调用put(String,String)结果。
    
    Specified by:
    
    putFloat 方法重写，继承类 Preferences
    
    参数
    
    key键的值的字符串形式是相关的。
    
    value值的字符串形式是与关键。
    
    异常
    
    NullPointerException如果关键是 null。
    
    IllegalArgumentException -如果 key.length()超过 MAX_KEY_LENGTH。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    Preferences.getFloat(String,float)
  - getFloat
```
public float getFloat(String key,
                      float def)
```
    实现了 getFloat方法按规范 Preferences.getFloat(String,float)。
    这get(key, null)实现调用。如果返回值为非零，实现试图将它与一个float Float.parseFloat(String)。如果尝试成功，返回值是通过该方法返回。否则，def返回。
    
    Specified by:
    
    getFloat 方法重写，继承类 Preferences
    
    参数
    
    key键的值作为浮返回。
    
    def -是在事件，这种偏好节点没有与 key或相关的价值不相关的值被解释为一个浮动的返回值。
    
    结果
    
    通过在这个节点 key偏好相关的字符串表示的浮点值，或 def如果关联的值不存在或不能被解释为一个浮动。
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    如果是 null key NullPointerException。
    
    另请参见：
    
    Preferences.putFloat(String,float)， Preferences.get(String,String)
  - putDouble
```
public void putDouble(String key,
                      double value)
```
    实现了 putDouble方法按规范 Preferences.putDouble(String,double)。
    这将value实施了一系列与Double.toString(double)和调用put(String,String)结果。
    
    Specified by:
    
    putDouble 方法重写，继承类 Preferences
    
    参数
    
    key键的值的字符串形式是相关的。
    
    value值的字符串形式是与关键。
    
    异常
    
    NullPointerException如果关键是 null。
    
    IllegalArgumentException -如果 key.length()超过 MAX_KEY_LENGTH。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    Preferences.getDouble(String,double)
  - getDouble
```
public double getDouble(String key,
                        double def)
```
    实现了 getDouble方法按规范 Preferences.getDouble(String,double)。
    这get(key, null)实现调用。如果返回值为非零，实现试图将它与一个double Double.parseDouble(String)。如果尝试成功，则该方法返回返回值。否则，def返回。
    
    Specified by:
    
    getDouble 方法重写，继承类 Preferences
    
    参数
    
    key键的值是作为一个双回来。
    
    def -是在事件，这种偏好节点没有与 key或相关的价值不相关的值被解释为一个双重的返回值。
    
    结果
    
    通过在这个节点 key偏好相关的字符串表示的双重价值，或 def如果关联的值不存在或不能被解释为一个双。
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    如果是 null key NullPointerException。
    
    另请参见：
    
    Preferences.putDouble(String,double)， Preferences.get(String,String)
  - putByteArray
```
public void putByteArray(String key,
                         byte[] value)
```
    实现了 putByteArray方法按规范 Preferences.putByteArray(String,byte[])。
    
    Specified by:
    
    putByteArray 方法重写，继承类 Preferences
    
    参数
    
    key键的值的字符串形式是相关的。
    
    value值的字符串形式是与关键。
    
    异常
    
    NullPointerException如果键或值 null。
    
    IllegalArgumentException如果关键。length()超过max_key_length或者value.length超过max_value_length * 3 / 4。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    Preferences.getByteArray(String,byte[])， Preferences.get(String,String)
  - getByteArray
```
public byte[] getByteArray(String key,
                           byte[] def)
```
    实现了 getByteArray方法按规范 Preferences.getByteArray(String,byte[])。
    
    Specified by:
    
    getByteArray 方法重写，继承类 Preferences
    
    参数
    
    key键的值是作为一个字节数组返回。
    
    def -是在事件，这种偏好节点没有与 key或相关的价值不相关的值被解释为一个字节数组中返回的值。
    
    结果
    
    通过在这个节点 key偏好相关的字符串表示的字节数组的值，或 def如果关联的值不存在或不能被解释为一个字节数组。
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    如果是 null key NullPointerException。（为 def一 null价值是允许的。）
    
    另请参见：
    
    Preferences.get(String,String)， Preferences.putByteArray(String,byte[])
  - keys
```
public String[] keys()
              throws BackingStoreException
```
    实现了 keys方法按规范
    这个实现得到这种偏好节点的锁，检查该节点没有被调用keysSpi()。
    Preferences.keys()。
    
    Specified by:
    
    keys 方法重写，继承类 Preferences
    
    结果
    
    在该首选项节点中有关联的值的键的数组。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
  - childrenNames
```
public String[] childrenNames()
                       throws BackingStoreException
```
    实现了 children方法按规范
    这个实现得到这种偏好节点的锁，检查该节点没有被拆除，构建了一个TreeSet初始化为孩子已缓存的名字（孩子们在这个节点的孩子”缓存”），调用childrenNamesSpi()，并添加所有返回的孩子名字进入设置。树的集合中的元素是倒入用toArray方法String阵列，该阵列返回。
    Preferences.childrenNames()。
    
    Specified by:
    
    childrenNames 方法重写，继承类 Preferences
    
    结果
    
    这个偏好节点的孩子的名字。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    cachedChildren()
  - cachedChildren
```
protected final AbstractPreferences[] cachedChildren()
```
    返回此节点的所有已知的初始的孩子。
    
    结果
    
    所有已知的初始孩子这个节点。
  - parent
```
public Preferences parent()
```
    实现了 parent方法按规范
    此实现获得此偏好节点的锁，检查该节点没有被删除，并返回传递给该节点的构造函数的父值。
    Preferences.parent()。
    
    Specified by:
    
    parent 方法重写，继承类 Preferences
    
    结果
    
    此偏好节点的父。
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
  - node
```
public Preferences node(String path)
```
    实现了 node方法按规范 Preferences.node(String)。
    此实现获得此偏好节点的锁，并检查该节点没有被删除。如果path是""，该节点；如果path是"/"，这个节点的根返回。如果第一个字符是不path '/'，实现突破path为记号和递归地遍历路径从该节点到节点命名，“消费”一个名字和一个斜线从path在遍历的每一步。在每一步骤中，当前节点被锁定，并检查节点的子缓存是否被命名的节点。如果没有找到，名字是检查以确定其长度不超过MAX_NAME_LENGTH。然后childSpi(String)方法被调用时，其结果存储在该节点的子高速缓存。如果新创建的Preferences对象的newNode场true有任何节点改变监听器，通知事件排队处理的事件调度线程。
    
    当有任何标记，最后一个值在缓存中找到返回的孩子或childSpi是由该方法返回。如果在遍历，两"/"令牌连续发生，或最终令牌"/"（而不是一个名字），一个合适的IllegalArgumentException抛出。
    
    如果第一个字符是'/' path（表示绝对路径名）这一偏好的节点的锁掉打破path为记号之前，该方法递归地遍历路径从根（而不是从这个节点）。该遍历与所描述的相对路径名的另一个相同。把锁在这个节点开始遍历根节点之前是避免死锁的可能性，必要的，按locking invariant。
    
    Specified by:
    
    node 方法重写，继承类 Preferences
    
    参数
    
    path -偏好节点的路径名称返回。
    
    结果
    
    指定的首选节点。
    
    异常
    
    IllegalArgumentException如果路径名无效（即，它包含多个斜杠字符，或者用斜杠字符结束，不仅仅是一个字符）。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    Preferences.flush()
  - nodeExists
```
public boolean nodeExists(String path)
                   throws BackingStoreException
```
    实现了 nodeExists方法按规范
    这个实现是node(String)非常相似，除了getChild(String)代替childSpi(String)。
    Preferences.nodeExists(String)。
    
    Specified by:
    
    nodeExists 方法重写，继承类 Preferences
    
    参数
    
    path -节点的存在是要检查路径名。
    
    结果
    
    如果指定的节点存在，则是真的。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
    
    IllegalArgumentException如果路径名无效（即，它包含多个斜杠字符，或者用斜杠字符结束，不仅仅是一个字符）。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()方法和 pathname删除不是空字符串（ ""）。
  - removeNode
```
public void removeNode()
                throws BackingStoreException
```
    实现了 removeNode()方法按规范 Preferences.removeNode()。
    此实现检查查看此节点是根；如果是，则抛出一个适当的异常。然后，它锁定该节点的父节点，并调用一个递归辅助方法遍历子树扎根在这个节点。递归方法锁定的节点被称为，检查它已经不能被删除，并确保所有的孩子：childrenNamesSpi()缓存的方法调用和返回的每一个孩子的名字是检查孩子的缓存控制。如果一个孩子是不是已经缓存的childSpi(String)方法被调用来为它创建一个Preferences实例，并放进孩子的缓存实例。然后，辅助方法在子缓存中包含的每个节点上递归调用自己的子节点。接下来，它调用removeNodeSpi()，标志本身删除，并删除本身从它的父的孩子缓存。最后，如果有任何节点改变监听器，它入队处理通知事件的事件调度线程。
    
    请注意，帮助器方法总是与所有的祖先一起调用“最接近的非被删除的祖先”锁定的。
    
    Specified by:
    
    removeNode 方法重写，继承类 Preferences
    
    异常
    
    IllegalStateException -如果此节点（或祖先）已经与 removeNode()法去除。
    
    UnsupportedOperationException -如果这方法在根节点调用。
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
    
    另请参见：
    
    Preferences.flush()
  - name
```
public String name()
```
    实现了 name方法按规范 Preferences.name()。
    此实现只返回传递给此节点的构造函数的名称。
    
    Specified by:
    
    name 方法重写，继承类 Preferences
    
    结果
    
    此首选节点的名称，相对于它的父。
  - absolutePath
```
public String absolutePath()
```
    实现了 absolutePath方法按规范 Preferences.absolutePath()。
    此实现只返回此节点构建的时间计算的绝对路径名（基于传递给此节点的构造函数的名称，以及传递给此节点的祖先构造函数的名称）。
    
    Specified by:
    
    absolutePath 方法重写，继承类 Preferences
    
    结果
    
    此首选节点的绝对路径名。
  - isUserNode
```
public boolean isUserNode()
```
    实现了 isUserNode方法按规范 Preferences.isUserNode()。
    这个实现比较这个节点的根节点（这是存储在一个私人领域）的返回值Preferences.userRoot()。如果两个对象引用是相同的，则该方法返回真。
    
    Specified by:
    
    isUserNode 方法重写，继承类 Preferences
    
    结果
    
    如果这 true偏好节点在用户偏好树， false如果它在系统偏好树。
  - addPreferenceChangeListener
```
public void addPreferenceChangeListener(PreferenceChangeListener pcl)
```
    从阶级复制的描述： Preferences
    
    寄存器指定监听器接收偏好变化事件这种偏好结。当将偏好添加到该节点中时，从该节点中移除或改变与偏好相关的值时，产生一个偏好变化事件。（偏好改变事件的不 Preferences.removeNode()方法，产生一个节点变化事件生成。偏好改变的事件是 clear方法产生
    事件是只保证在相同的JVM为注册侦听器的变化，尽管一些实现可能产生了在JVM变化事件。事件可能在更改之前生成已被持久化。当此节点的子类中的偏好被修改时，事件不会产生；希望这样的事件的调用方必须在每个子代中注册。
    。）
    
    Specified by:
    
    addPreferenceChangeListener 方法重写，继承类 Preferences
    
    参数
    
    pcl的偏好改变监听器添加。
    
    另请参见：
    
    Preferences.removePreferenceChangeListener(PreferenceChangeListener)， Preferences.addNodeChangeListener(NodeChangeListener)
  - removePreferenceChangeListener
```
public void removePreferenceChangeListener(PreferenceChangeListener pcl)
```
    从阶级复制的描述： Preferences
    
    移除指定的偏好更改侦听器，所以它不再接收偏好更改事件。
    
    Specified by:
    
    removePreferenceChangeListener 方法重写，继承类 Preferences
    
    参数
    
    pcl的偏好改变监听器移除。
    
    另请参见：
    
    Preferences.addPreferenceChangeListener(PreferenceChangeListener)
  - addNodeChangeListener
```
public void addNodeChangeListener(NodeChangeListener ncl)
```
    从阶级复制的描述： Preferences
    
    寄存器指定监听器接收节点变化事件此节点。当将子节点添加到或从该节点中删除时，生成一个节点更改事件。（一 Preferences.removeNode()调用结果多节点变化事件，一为根的子树中被删除的节点，每个节点
    事件是只保证在相同的JVM为注册侦听器的变化，尽管一些实现可能产生了在JVM变化事件。在更改已成为永久性之前，可能会产生事件。当此节点的间接后裔被添加或删除时，不产生事件；希望这样的事件的调用方必须在每个子代中注册。
    
    关于节点创建可以提供一些保证。因为节点隐式地创建访问时，它可能无法实现确定之前访问后台存储存在子节点是可行的（例如，由于支持存储访问或缓存信息过时）。在这种情况下，实现都不需要生成节点更改事件，也不禁止这样做。
    ）
    
    Specified by:
    
    addNodeChangeListener 方法重写，继承类 Preferences
    
    参数
    
    ncl - NodeChangeListener添加。
    
    另请参见：
    
    Preferences.removeNodeChangeListener(NodeChangeListener)， Preferences.addPreferenceChangeListener(PreferenceChangeListener)
  - removeNodeChangeListener
```
public void removeNodeChangeListener(NodeChangeListener ncl)
```
    从阶级复制的描述： Preferences
    
    移除指定的 NodeChangeListener，所以它不再接受变更事件。
    
    Specified by:
    
    removeNodeChangeListener 方法重写，继承类 Preferences
    
    参数
    
    ncl - NodeChangeListener删除。
    
    另请参见：
    
    Preferences.addNodeChangeListener(NodeChangeListener)
  - putSpi
```
protected abstract void putSpi(String key,
                               String value)
```
    将给定的键值关联到这个首选节点上。这是保证 key和 value均非空且合法的长度。此外，它保证这个节点没有被删除。（作者不必检查任何这些事情。）
    此方法在这个节点上的锁被调用。
    
    参数
    
    key的关键
    
    value -价值
  - getSpi
```
protected abstract String getSpi(String key)
```
    返回与指定的键在这个偏好节点关联的值，或 null如果没有协会或协会这一关键，此时无法确定。这是保证 key非空。此外，它保证这个节点没有被删除。（作者不需要检查这些东西。）
    一般来说，这种方法在任何情况下都不应该抛出一个异常。如果，但是，如果它不抛出异常，该异常将被视为一个null返回值。
    
    此方法在这个节点上的锁被调用。
    
    参数
    
    key的关键
    
    结果
    
    具有指定键在这个偏好节点关联的值，或 null如果没有协会或协会这一关键，此时无法确定。
  - removeSpi
```
protected abstract void removeSpi(String key)
```
    删除此首选项节点中指定的键的关联（如果有的话）。这是保证 key非空。此外，它保证这个节点没有被删除。（作者不需要检查这些东西。）
    此方法在这个节点上的锁被调用。
    
    参数
    
    key的关键
  - removeNodeSpi
```
protected abstract void removeNodeSpi()
                               throws BackingStoreException
```
    消除这种偏好的节点，它失效，它包含任何偏好。命名的孩子会没有后代的同时调用了（即，该 Preferences.removeNode()方法调用该方法多次在自底向上的方式，消除每一个节点的子孙除节点本身之前）。
    这种方法是用锁于此节点及其母调用（和所有的祖先都被作为一个结果，调用Preferences.removeNode()删除）。
    
    一个节点的去除不必成为持续直到flush方法在此节点上调用（或祖先）。
    
    如果这个节点抛出一个BackingStoreException，异常将传播超出了封闭removeNode()调用。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
  - keysSpi
```
protected abstract String[] keysSpi()
                             throws BackingStoreException
```
    返回在这个首选项节点中有关联的值的所有键。如果这个节点没有首选项，则返回的数组将是大小为零的。）保证这个节点没有被删除。
    此方法在这个节点上的锁被调用。
    
    如果这个节点抛出一个BackingStoreException，异常将传播超出了封闭keys()调用。
    
    结果
    
    在该首选项节点中有关联的值的键的数组。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
  - childrenNamesSpi
```
protected abstract String[] childrenNamesSpi()
                                      throws BackingStoreException
```
    返回此首选节点的子节点的名称。（返回的数组将是大小为零，如果这个节点没有孩子。）这种方法不需要返回已经缓存的任何节点的名称，但可以这样做没有伤害。
    此方法在这个节点上的锁被调用。
    
    如果这个节点抛出一个BackingStoreException，异常将传播超出了封闭childrenNames()调用。
    
    结果
    
    包含此首选节点的子节点的数组的数组。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
  - getChild
```
protected AbstractPreferences getChild(String nodeName)
                                throws BackingStoreException
```
    返回指定的孩子，如果它存在，或 null如果不。这是保证 nodeName非空，非空，不包含反斜杠字符（“/”），而不再是 Preferences.MAX_NAME_LENGTH字符。此外，它保证这个节点没有被删除。（作者不必检查任何这些事情，如果他选择重写此方法。）
    最后，这是保证指定的节点未返回之前调用此方法或childSpi(java.lang.String)，它被删除后最后一次。换言之，一个缓存的值将始终被用于调用此方法的优先权。（作者不必维护自己的缓存先前返回的孩子如果他选择重写此方法。）
    
    这个实现得到这种偏好节点的锁，调用childrenNames()得到该节点的子节点名称的数组，遍历比较每个孩子的名字与指定的节点名称的数组。如果一个孩子节点有正确的名称，该childSpi(String)方法被调用而产生的节点。如果迭代完成没有找到指定的名称，null返回。
    
    参数
    
    nodeName -孩子的名字进行搜索。
    
    结果
    
    命名的子，如果它存在，或空，如果它不。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
  - childSpi
```
protected abstract AbstractPreferences childSpi(String name)
```
    返回此首选节点的命名子节点，如果它不已经存在，则创建它。这是保证 name非空，非空，不包含反斜杠字符（“/”），而不再是 Preferences.MAX_NAME_LENGTH字符。此外，它保证这个节点没有被删除。（作者不必检查任何这些事情。）
    最后，这是保证指定的节点未返回之前调用此方法或getChild(String)，它被删除后最后一次。换言之，一个缓存的值将始终被用于调用此方法的优先权。子类不必维护自己以前返回的子类的缓存。
    
    实施者必须确保返回的节点未被删除。如果一个孩子喜欢称这个节点是以前删除，实施者必须返回一个新建的AbstractPreferences节点；一旦删除，一个AbstractPreferences节点不能“复苏”。
    
    如果这个方法使节点被创建，这个节点不一定会持续直到flush方法在此节点或其祖先之一调用（或后代）。
    
    此方法在这个节点上的锁被调用。
    
    参数
    
    name -返回的子节点的名称，相对于这一偏好的结。
    
    结果
    
    命名子节点。
  - toString
```
public String toString()
```
    返回此首选项节点的绝对路径名称。
    
    Specified by:
    
    toString 方法重写，继承类 Preferences
    
    结果
    
    对象的字符串表示形式。
  - sync
```
public void sync()
          throws BackingStoreException
```
    实现了 sync方法按规范 Preferences.sync()。
    这要求执行递归的辅助方法，锁定此节点，调用syncspi()它，打开这个结，并递归地调用该方法，每个缓存缓存的孩子。”孩子是该节点已经在VM创建并不是随后删除的孩子。实际上，这种方法是深度优先遍历的“缓存子树”扎根在这个节点，每个节点上调用syncspi()子树中的节点上，而只有。注意，调用syncspi()自上而下。
    
    Specified by:
    
    sync 方法重写，继承类 Preferences
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
    
    IllegalStateException -如果此节点（或祖先）已与 removeNode()法去除。
    
    另请参见：
    
    flush()
  - syncSpi
```
protected abstract void syncSpi()
                         throws BackingStoreException
```
    此方法被调用此节点锁定。该方法的合同是将存储在该节点上的任何缓存的首选项与存储在后台存储区中的任何一种同步的方法进行同步。（这是完全可能的，这个节点上不存在后备存储，因为它已经被另一个虚拟机，删除或因为它尚未被创建。）注意：此方法应不同步偏好在任何子节点的节点。如果存储支持自然同步整个子树时，实施者是鼓励sync()重写，而不是重写该方法。
    如果这个节点抛出一个BackingStoreException，异常将传播超出了封闭sync()调用。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
  - flush
```
public void flush()
           throws BackingStoreException
```
    实现了 flush方法按规范 Preferences.flush()。
    这要求执行递归的辅助方法，锁定此节点，调用flushspi()它，打开这个结，并递归地调用该方法，每个缓存缓存的孩子。”孩子是该节点已经在VM创建并不是随后删除的孩子。实际上，这种方法是深度优先遍历的“缓存子树”扎根在这个节点，每个节点上调用flushspi()子树中的节点上，而只有。注意，调用flushspi()自上而下。
    
    如果这个方法是一个节点，已与removeNode()方法除去调用，flushspi()正在此节点上调用的，而不是别人。
    
    Specified by:
    
    flush 方法重写，继承类 Preferences
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
    
    另请参见：
    
    flush()
  - flushSpi
```
protected abstract void flushSpi()
                          throws BackingStoreException
```
    此方法被调用此节点锁定。该方法的合同将强制将此偏好节点的内容的任何缓存更改为支持存储，以保证它们的持久性。（这是完全可能的，这个节点上不存在后备存储，因为它已经被另一个虚拟机，删除或因为它尚未被创建。）注意：此方法应不冲洗的偏好在任何子节点，该节点。如果存储支持，自然冲的整个子树时，实施者是鼓励flush()重写，而不是重写该方法。
    如果这个节点抛出一个BackingStoreException，异常将传播超出了封闭flush()调用。
    
    异常
    
    BackingStoreException -如果此操作不能由于在存储备份失败的完成，或无法与它沟通。
  - isRemoved
```
protected boolean isRemoved()
```
    返回 true敌我识别这个节点（或祖先）已与 removeNode()法去除。此方法在返回用于跟踪该状态的私有字段的内容之前锁定此节点。
    
    结果
    
    true敌我识别这个节点（或祖先）已与 removeNode()法去除。
  - exportNode
```
public void exportNode(OutputStream os)
                throws IOException,
                       BackingStoreException
```
    实现了 exportNode方法按规范 Preferences.exportNode(OutputStream)。
    
    Specified by:
    
    exportNode 方法重写，继承类 Preferences
    
    参数
    
    os -在输出流发出的XML文档。
    
    异常
    
    IOException如果写入到指定的输出流中 IOException。
    
    BackingStoreException如果偏好数据不能从后备存储读取。
    
    另请参见：
    
    Preferences.importPreferences(InputStream)
  - exportSubtree
```
public void exportSubtree(OutputStream os)
                   throws IOException,
                          BackingStoreException
```
    实现了 exportSubtree方法按规范 Preferences.exportSubtree(OutputStream)。
    
    Specified by:
    
    exportSubtree 方法重写，继承类 Preferences
    
    参数
    
    os -在输出流发出的XML文档。
    
    异常
    
    IOException如果写入到指定的输出流中 IOException。
    
    BackingStoreException如果偏好数据不能从后备存储读取。
    
    另请参见：
    
    Preferences.importPreferences(InputStream)， Preferences.exportNode(OutputStream)

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class AbstractPreferences

Field Summary

Fields inherited from class java.util.prefs.Preferences

构造方法摘要

方法摘要

Methods inherited from class java.util.prefs.Preferences

Methods inherited from class java.lang.Object

Field Detail

newNode

lock

Constructor Detail

AbstractPreferences

方法详细信息

put

get

remove

clear

putInt

getInt

putLong

getLong

putBoolean

getBoolean

putFloat

getFloat

putDouble

getDouble

putByteArray

getByteArray

keys

childrenNames

cachedChildren

parent

node

nodeExists

removeNode

name

absolutePath

isUserNode

addPreferenceChangeListener

removePreferenceChangeListener

addNodeChangeListener

removeNodeChangeListener

putSpi

getSpi

removeSpi

removeNodeSpi

keysSpi

childrenNamesSpi

getChild

childSpi

toString

sync

syncSpi

flush

flushSpi

isRemoved

exportNode

exportSubtree