в 17:44, 31 мая 2010

2010-05-31T17:44:27Z

Admin: 1 версия

2010-05-31T15:28:35Z

1 версия

Новая страница

== Determining If a Preference Node Contains a Specific Key ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
}
// Returns true if node contains the specified key; false otherwise.
public static boolean contains(Preferences node, String key) {
return node.get(key, null) != null;
}
}</source>



== Determining If a Preference Node Contains a Specific Value ==



<source lang="java">
import java.util.prefs.BackingStoreException;
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
}

public static String containsValue(Preferences node, String value) {
try {
String[] keys = node.keys();
for (int i = 0; i < keys.length; i++) {
if (value.equals(node.get(keys[i], null))) {
return keys[i];
}
}
} catch (BackingStoreException e) {
}
return null;
}
}</source>



== Determining If a Preference Node Exists ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
boolean exists = Preferences.userRoot().nodeExists("/yourValue"); // false
Preferences.userRoot().node("/yourValue");
exists = Preferences.userRoot().nodeExists("/yourValue"); // true
Preferences prefs = Preferences.userRoot().node("/yourValue");
prefs.removeNode();
// exists = prefs.nodeExists("/yourValue");
exists = prefs.nodeExists(""); // false
}
}</source>



== Determining When a Preference Node Is Added or Removed ==



<source lang="java">
import java.util.prefs.NodeChangeEvent;
import java.util.prefs.NodeChangeListener;
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
Preferences prefs = Preferences.userNodeForPackage(String.class);
prefs.addNodeChangeListener(new NodeChangeListener() {
public void childAdded(NodeChangeEvent evt) {
Preferences parent = evt.getParent();
Preferences child = evt.getChild();
}
public void childRemoved(NodeChangeEvent evt) {
Preferences parent = evt.getParent();
Preferences child = evt.getChild();
}
});
Preferences child = prefs.node("new node");
child.removeNode();
prefs.removeNode();
}
}</source>



== Exporting the Preferences in a Preference Node ==



<source lang="java">
import java.io.FileOutputStream;
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
Preferences prefs = Preferences.userNodeForPackage(String.class);
// Save some values
prefs.put("myString", "a string"); // String
prefs.putBoolean("myBoolean", true); // boolean
prefs.putInt("myInt", 123); // int
prefs.putLong("myLong", 123L); // long
prefs.putFloat("myFloat", 12.3F); // float
prefs.putDouble("myDouble", 12.3); // double
byte[] bytes = new byte[10];
prefs.putByteArray("myByteArray", bytes); // byte[]
// Export the node to a file
prefs.exportNode(new FileOutputStream("output.xml"));
}
}</source>



== Exporting the Preferences in a Subtree of Preference Nodes ==



<source lang="java">
import java.io.FileOutputStream;
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
Preferences prefs = Preferences.userNodeForPackage(String.class);
// Save some values
prefs.put("myString", "a string"); // String
prefs.putBoolean("myBoolean", true); // boolean
prefs.putInt("myInt", 123); // int
prefs.putLong("myLong", 123L); // long
// Save some values in the parent node
prefs = prefs.parent();
prefs.putFloat("myFloat", 12.3F); // float
prefs.putDouble("myDouble", 12.3); // double
byte[] bytes = new byte[10];
prefs.putByteArray("myByteArray", bytes); // byte[]
prefs.exportSubtree(new FileOutputStream("output.xml"));
}
}</source>



== Export Preferences to XML file ==



<source lang="java">
import java.io.FileOutputStream;
import java.util.prefs.Preferences;
public class PreferenceExample {
public static void main(String args[]) throws Exception {
Preferences prefsRoot = Preferences.userRoot();
Preferences myPrefs = prefsRoot.node("PreferenceExample");
myPrefs.put("A", "a");
myPrefs.put("B", "b");
myPrefs.put("C", "c");
FileOutputStream fos = new FileOutputStream("prefs.xml");
myPrefs.exportSubtree(fos);
fos.close();
}
}</source>



== Get childrenNames from Preferences ==



<source lang="java">
import java.io.FileOutputStream;
import java.util.prefs.Preferences;
public class PreferenceExample {
public static void main(String args[]) throws Exception {
Preferences prefsRoot = Preferences.userRoot();
Preferences myPrefs = prefsRoot.node("PreferenceExample");
myPrefs.put("A", "a");
myPrefs.put("B", "b");
myPrefs.put("C", "c");
System.out.print("Node"s children: ");
for (String s : myPrefs.childrenNames()) {
System.out.print(s + "");
}

}
}</source>



== Get keys from Preferences ==



<source lang="java">
import java.io.FileOutputStream;
import java.util.prefs.Preferences;
public class PreferenceExample {
public static void main(String args[]) throws Exception {
Preferences prefsRoot = Preferences.userRoot();
Preferences myPrefs = prefsRoot.node("PreferenceExample");
myPrefs.put("A", "a");
myPrefs.put("B", "b");
myPrefs.put("C", "c");
System.out.print("Node"s keys: ");
for (String s : myPrefs.keys()) {
System.out.print(s + "");
}
}
}</source>



== Get name and parent from Preference ==



<source lang="java">
import java.util.prefs.Preferences;
public class PreferenceExample {
public static void main(String args[]) throws Exception {
Preferences prefsRoot = Preferences.userRoot();
Preferences myPrefs = prefsRoot.node("PreferenceExample");
myPrefs.put("A", "a");
myPrefs.put("B", "b");
myPrefs.put("C", "c");
System.out.println("Node"s name: " + myPrefs.name());
System.out.println("Node"s parent: " + myPrefs.parent());
System.out.println("NODE: " + myPrefs);
}
}</source>



== Get node from Preference ==



<source lang="java">
import java.util.prefs.Preferences;
public class PreferenceExample {
public static void main(String args[]) throws Exception {
Preferences prefsRoot = Preferences.userRoot();
Preferences myPrefs = prefsRoot.node("PreferenceExample");
myPrefs.put("A", "a");
myPrefs.put("B", "b");
myPrefs.put("C", "c");
System.out.println("userNodeForPackage: "
+ Preferences.userNodeForPackage(PreferenceExample.class));
}
}</source>



== Get the desired look and feel from a per-user preference ==



<source lang="java">
/*
* Copyright (c) 2004 David Flanagan. All rights reserved.
* This code is from the book Java Examples in a Nutshell, 3nd Edition.
* It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
* You may study, use, and modify it for any non-commercial purpose,
* including teaching and use in open-source projects.
* You may distribute it non-commercially as long as you retain this notice.
* For a commercial use license, or to purchase the book,
* please visit http://www.davidflanagan.ru/javaexamples3.
*/
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.prefs.Preferences;
import javax.swing.ButtonGroup;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
public class LookAndFeelPrefs {
public static final String PREF_NAME = "preferredLookAndFeelClassName";
/**
* Get the desired look and feel from a per-user preference. If the
* preferences doesn"t exist or is unavailable, use the default look and feel.
* The preference is shared by all classes in the same package as prefsClass.
*/
public static void setPreferredLookAndFeel(Class prefsClass) {
Preferences prefs = Preferences.userNodeForPackage(prefsClass);
String defaultLAF = UIManager.getSystemLookAndFeelClassName();
String laf = prefs.get(PREF_NAME, defaultLAF);
try {
UIManager.setLookAndFeel(laf);
} catch (Exception e) { // ClassNotFound or InstantiationException
// An exception here is probably caused by a bogus preference.
// Ignore it silently; the user will make do with the default LAF.
}
}
/**
* Create a menu of radio buttons listing the available Look and Feels. When
* the user selects one, change the component hierarchy under frame to the new
* LAF, and store the new selection as the current preference for the package
* containing class c.
*/
public static JMenu createLookAndFeelMenu(final Class prefsClass, final ActionListener listener) {
// Create the menu
final JMenu plafmenu = new JMenu("Look and Feel");
// Create an object used for radio button mutual exclusion
ButtonGroup radiogroup = new ButtonGroup();
// Look up the available look and feels
UIManager.LookAndFeelInfo[] plafs = UIManager.getInstalledLookAndFeels();
// Find out which one is currently used
String currentLAFName = UIManager.getLookAndFeel().getClass().getName();
// Loop through the plafs, and add a menu item for each one
for (int i = 0; i < plafs.length; i++) {
String plafName = plafs[i].getName();
final String plafClassName = plafs[i].getClassName();
// Create the menu item
final JMenuItem item = plafmenu.add(new JRadioButtonMenuItem(plafName));
item.setSelected(plafClassName.equals(currentLAFName));
// Tell the menu item what to do when it is selected
item.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
// Set the new look and feel
try {
UIManager.setLookAndFeel(plafClassName);
} catch (UnsupportedLookAndFeelException e) {
// Sometimes a Look-and-Feel is installed but not
// supported, as in the Windows LaF on Linux platforms.
JOptionPane.showMessageDialog(plafmenu, "The selected Look-and-Feel is "
+ "not supported on this platform.", "Unsupported Look And Feel",
JOptionPane.ERROR_MESSAGE);
item.setEnabled(false);
} catch (Exception e) { // ClassNotFound or Instantiation
item.setEnabled(false); // shouldn"t happen
}
// Make the selection persistent by storing it in prefs.
Preferences p = Preferences.userNodeForPackage(prefsClass);
p.put(PREF_NAME, plafClassName);
// Invoke the supplied action listener so the calling
// application can update its components to the new LAF
// Reuse the event that was passed here.
listener.actionPerformed(event);
}
});
// Only allow one menu item to be selected at once
radiogroup.add(item);
}
return plafmenu;
}
}</source>



== Getting and Setting Java Type Values in a Preference ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
Preferences prefs = Preferences.userNodeForPackage(Main.class);
// Preference key name
final String PREF_NAME = "name_of_preference";
// Save
prefs.put(PREF_NAME, "a string"); // String
prefs.putBoolean(PREF_NAME, true); // boolean
prefs.putInt(PREF_NAME, 123); // int
prefs.putLong(PREF_NAME, 123L); // long
prefs.putFloat(PREF_NAME, 12.3F); // float
prefs.putDouble(PREF_NAME, 12.3); // double
byte[] bytes = new byte[1024];
prefs.putByteArray(PREF_NAME, bytes); // byte[]
// Retrieve
String s = prefs.get(PREF_NAME, "a string"); // String
boolean b = prefs.getBoolean(PREF_NAME, true); // boolean
int i = prefs.getInt(PREF_NAME, 123); // int
long l = prefs.getLong(PREF_NAME, 123L); // long
float f = prefs.getFloat(PREF_NAME, 12.3F); // float
double d = prefs.getDouble(PREF_NAME, 12.3); // double
bytes = prefs.getByteArray(PREF_NAME, bytes); // byte[]
}
}</source>



== Getting the Maximum Size of a Preference Key and Value ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
// Get maximum key length
int keyMax = Preferences.MAX_KEY_LENGTH;
// Get maximum value length
int valueMax = Preferences.MAX_VALUE_LENGTH;
// Get maximum length of byte array values
int bytesMax = Preferences.MAX_VALUE_LENGTH * 3 / 4;
}
}</source>



== Getting the Roots of the Preference Trees ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
// Get the system root
Preferences prefs = Preferences.systemRoot();
// Get the user root
prefs = Preferences.userRoot();
// The name of a root is ""
String name = prefs.name();
// The parent of a root is null
Preferences parent = prefs.parent();
// The absolute path of a root is "/"
String path = prefs.absolutePath();
}
}</source>



== Get value from Preferences ==



<source lang="java">
import java.util.prefs.Preferences;
public class PreferenceExample {
public static void main(String args[]) throws Exception {
Preferences prefsRoot = Preferences.userRoot();
Preferences myPrefs = prefsRoot.node("PreferenceExample");
myPrefs.put("A", "a");
myPrefs.put("B", "b");
myPrefs.put("C", "c");
for (String s : myPrefs.keys()) {
System.out.println("" + s + "= " + myPrefs.get(s, ""));
}
}
}</source>



== Listening for Changes to Preference Values in a Preference Node ==



<source lang="java">
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
Preferences prefs = Preferences.userNodeForPackage(String.class);
prefs.addPreferenceChangeListener(new PreferenceChangeListener() {
public void preferenceChange(PreferenceChangeEvent evt) {
Preferences node = evt.getNode();
String key = evt.getKey();
String newValue = evt.getNewValue();
}
});
prefs.put("key", "a string");
prefs.put("key", "a new string");
prefs.remove("key");
}
}</source>



== Preference save and load ==



<source lang="java">
import java.util.Arrays;
import java.util.Iterator;
import java.util.prefs.Preferences;
public class MainClass {
public static void main(String[] args) throws Exception {
Preferences prefs = Preferences.userNodeForPackage(MainClass.class);
prefs.put("key1", "value1");
prefs.put("key2", "value2");
prefs.putInt("intValue", 4);
prefs.putBoolean("booleanValue", true);
int usageCount = prefs.getInt("intValue", 0);
usageCount++;
prefs.putInt("UsageCount", usageCount);
Iterator it = Arrays.asList(prefs.keys()).iterator();
while (it.hasNext()) {
String key = it.next().toString();
System.out.println(key + ": " + prefs.get(key, null));
}
System.out.println(prefs.getInt("booleanValue", 0));
}
}</source>



== Preferences Inspector ==



<source lang="java">
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
public class MainClass implements PreferenceChangeListener {
private Preferences userPrefs;
public static final String NAMEPREF = "name";
public static final String EMAILPREF = "email";
public static final String AGEPREF = "age";
public static final String PHONEPREF = "phone";
public static void main(String args[]) {
new MainClass();
}
public MainClass() {
userPrefs = Preferences.userNodeForPackage(MainClass.class);
System.out.println(userPrefs.get(NAMEPREF, ""));
System.out.println(userPrefs.get(EMAILPREF, ""));
System.out.println(userPrefs.get(AGEPREF, ""));
System.out.println(userPrefs.get(PHONEPREF, ""));
userPrefs.put(NAMEPREF, "name");
userPrefs.put(AGEPREF, "Text");
userPrefs.put(EMAILPREF, "email");
userPrefs.put(PHONEPREF, "phone");
System.out.println("Preferences stored");
Preferences.userNodeForPackage(MainClass.class).addPreferenceChangeListener(this);
}
public void preferenceChange(PreferenceChangeEvent evt) {
String key = evt.getKey();
String val = evt.getNewValue();
if (key.equals(NAMEPREF)) {
System.out.println(val);
} else if (key.equals(EMAILPREF)) {
System.out.println(val);
} else if (key.equals(AGEPREF)) {
System.out.println(val);
} else if (key.equals(PHONEPREF)) {
System.out.println(val);
}
}
}</source>



== Put key value pair to Preference ==



<source lang="java">
import java.io.FileOutputStream;
import java.util.prefs.Preferences;
public class PreferenceExample {
public static void main(String args[]) throws Exception {
Preferences prefsRoot = Preferences.userRoot();
Preferences myPrefs = prefsRoot.node("PreferenceExample");
myPrefs.put("A", "a");
myPrefs.put("B", "b");
myPrefs.put("C", "c");
System.out.println("Node"s absolute path: " + myPrefs.absolutePath());
}
}</source>



== Read / write data in Windows registry ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] args) {
String PREF_KEY = "org.username";
// Write Preferences information to HKCU (HKEY_CURRENT_USER),HKCU\Software\JavaSoft\Prefs\
Preferences userPref = Preferences.userRoot();
userPref.put(PREF_KEY, "a");
System.out.println("Preferences = " + userPref.get(PREF_KEY, PREF_KEY + " was not found."));
// Write Preferences information to HKLM (HKEY_LOCAL_MACHINE),HKLM\Software\JavaSoft\Prefs\
Preferences systemPref = Preferences.systemRoot();
systemPref.put(PREF_KEY, "b");
System.out.println("Preferences = " + systemPref.get(PREF_KEY, PREF_KEY + " was not found."));
}
}</source>



== Removing a Preference from a Preference Node ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
// Get the user preference node for java.lang
Preferences prefs = Preferences.userNodeForPackage(String.class);
// Remove a preference in the node
final String PREF_NAME = "name_of_preference";
prefs.remove(PREF_NAME);
// Remove all preferences in the node
prefs.clear();
}
}</source>



== Removing a Preference Node ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
boolean exists = Preferences.userRoot().nodeExists("/yourValue"); // false
if (!exists) {
Preferences prefs = Preferences.userRoot().node("/yourValue");
prefs.removeNode();
// prefs.removeNode();
}
Preferences prefs = Preferences.userRoot().node("/yourValue/child");
exists = Preferences.userRoot().nodeExists("/yourValue"); // true
exists = Preferences.userRoot().nodeExists("/yourValue/child"); // true
Preferences.userRoot().node("/yourValue").removeNode();
exists = Preferences.userRoot().nodeExists("/yourValue"); // false
exists = Preferences.userRoot().nodeExists("/yourValue/child"); // false
}
}</source>



== Retrieving the Parent and Child Nodes of a Preference Node ==



<source lang="java">
import java.util.prefs.Preferences;
public class Main {
public static void main(String[] argv) throws Exception {
Preferences prefs = Preferences.userNodeForPackage(java.lang.String.class);
Preferences node = prefs.parent(); // /java
node = node.parent(); // null
String[] names = null;
names = prefs.childrenNames();
for (int i = 0; i < names.length; i++) {
node = prefs.node(names[i]);
}
}
}</source>

← Предыдущая	Версия 17:44, 31 мая 2010
(нет различий)

Java Tutorial/Development/Preference - История изменений

в 17:44, 31 мая 2010

Admin: 1 версия