Java Language
पसंद

algorithm Android HTML javafx JavaScript MySQL Regular Expressions spring spring-boot SQL
खोज…


इवेंट श्रोताओं को जोड़ना

Preferences ऑब्जेक्ट द्वारा उत्सर्जित दो प्रकार की घटनाएँ हैं: PreferenceChangeEvent NodeChangeEvent और NodeChangeEvent ।

PreferenceChangeEvent

एक PreferenceChangeEvent उत्सर्जित हो जाता है एक Properties नोड के मुख्य मान-जोड़े के परिवर्तन की हर बार एक आपत्ति है। PreferenceChangeEvent एक साथ के लिए बात सुनी जा सकती है PreferenceChangeListener :

जावा एसई 8 
preferences.addPreferenceChangeListener(evt -> {
    String newValue = evt.getNewValue();
    String changedPreferenceKey = evt.getKey();
    Preferences changedNode = evt.getNode();
});
जावा एसई 8 
preferences.addPreferenceChangeListener(new PreferenceChangeListener() {
    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        String newValue = evt.getNewValue();
        String changedPreferenceKey = evt.getKey();
        Preferences changedNode = evt.getNode();
    }
});

यह श्रोता बच्चे के नोड्स के बदले गए महत्वपूर्ण-मूल्य जोड़े को नहीं सुनेंगे।

NodeChangeEvent

जब भी Properties नोड का बच्चा नोड जोड़ा जाता है या हटाया जाता है तो इस घटना को निकाल दिया जाएगा। 

preferences.addNodeChangeListener(new NodeChangeListener() {
    @Override
    public void childAdded(NodeChangeEvent evt) {
        Preferences addedChild = evt.getChild();
        Preferences parentOfAddedChild = evt.getParent();
    }

    @Override
    public void childRemoved(NodeChangeEvent evt) {
        Preferences removedChild = evt.getChild();
        Preferences parentOfRemovedChild = evt.getParent();
    }
});

वरीयताएँ के उप-नोड्स प्राप्त करना

Preferences वस्तुएं हमेशा पूरे Preferences पेड़ में एक विशिष्ट नोड का प्रतिनिधित्व करती हैं, इस तरह से: 

/userRoot
├── com
│   └── mycompany
│       └── myapp
│           ├── darkApplicationMode=true
│           ├── showExitConfirmation=false
│           └── windowMaximized=true
└── org
    └── myorganization
        └── anotherapp
            ├── defaultFont=Helvetica
            ├── defaultSavePath=/home/matt/Documents
            └── exporting
                ├── defaultFormat=pdf
                └── openInBrowserAfterExport=false

/com/mycompany/myapp नोड का चयन करने के लिए:

  1. एक वर्ग के पैकेज के आधार पर सम्मेलन द्वारा: 

    package com.mycompany.myapp;

// ...

// Because this class is in the com.mycompany.myapp package, the node
// /com/mycompany/myapp will be returned.
Preferences myApp = Preferences.userNodeForPackage(getClass());

  2. सापेक्ष पथ द्वारा: 

    Preferences myApp = Preferences.userRoot().node("com/mycompany/myapp");

    एक सापेक्ष पथ ( / साथ शुरू नहीं होने वाला पथ) का उपयोग करने से उस मूल नोड के सापेक्ष पथ को हल करने का कारण होगा जिस पर इसे हल किया गया है। उदाहरण के लिए, निम्न उदाहरण पथ /one/two/three/com/mycompany/myapp का नोड लौटाएगा: 

    Preferences prefix = Preferences.userRoot().node("one/two/three");
Preferences myAppWithPrefix = prefix.node("com/mycompany/myapp");
// prefix          is /one/two/three
// myAppWithPrefix is /one/two/three/com/mycompany/myapp

  3. निरपेक्ष मार्ग से: 

    Preferences myApp = Preferences.userRoot().node("/com/mycompany/myapp");

    रूट नोड पर एक निरपेक्ष पथ का उपयोग करना सापेक्ष पथ का उपयोग करने से अलग नहीं होगा। अंतर यह है कि, यदि उप-नोड पर कॉल किया जाता है, तो रूट नोड के सापेक्ष हल हो जाएगा। 

    Preferences prefix = Preferences.userRoot().node("one/two/three");
Preferences myAppWitoutPrefix = prefix.node("/com/mycompany/myapp");
// prefix            is /one/two/three
// myAppWitoutPrefix is /com/mycompany/myapp

कई अनुप्रयोगों के उदाहरणों में समन्वय वरीयताएँ पहुँचती हैं

Preferences सभी उदाहरण हमेशा एकल जावा वर्चुअल मशीन (JVM) के थ्रेड्स में थ्रेड-सुरक्षित होते हैं। क्योंकि Preferences कई JVM में साझा की जा सकती हैं, ऐसे विशेष तरीके हैं जो आभासी मशीनों में परिवर्तन को सिंक्रनाइज़ करने के साथ काम करते हैं।

यदि आपके पास एक ऐसा एप्लिकेशन है जो केवल एक ही उदाहरण में चलना है, तो किसी बाहरी सिंक्रनाइज़ेशन की आवश्यकता नहीं है।

यदि आपके पास एक ऐसा एप्लिकेशन है जो एक सिस्टम पर कई इंस्टेंसेस में चलता है और इसलिए सिस्टम पर JVMs के बीच Preferences एक्सेस को समन्वित करने की आवश्यकता होती है, तो किसी भी Preferences नोड के sync() विधि का उपयोग Preferences नोड में परिवर्तन सुनिश्चित करने के लिए किया जा सकता है। सिस्टम पर अन्य JVM के लिए दृश्यमान: 

// Warning: don't use this if your application is intended
// to only run a single instance on a machine once
// (this is probably the case for most desktop applications)
try {
    preferences.sync();
} catch (BackingStoreException e) {
    // Deal with any errors while saving the preferences to the backing storage
    e.printStackTrace();
}

प्राथमिकताएँ निर्यात करना

Preferences नोड्स को उस नोड का प्रतिनिधित्व करने वाले XML दस्तावेज़ में निर्यात किया जा सकता है। परिणामस्वरूप XML ट्री को फिर से आयात किया जा सकता है। परिणामस्वरूप XML दस्तावेज़ याद रखेगा कि क्या इसे उपयोगकर्ता या सिस्टम Preferences से निर्यात किया गया था।

एकल नोड निर्यात करने के लिए, लेकिन इसका बच्चा नोड नहीं :

जावा एसई 7 
try (OutputStream os = ...) {
    preferences.exportNode(os);
} catch (IOException ioe) {
    // Exception whilst writing data to the OutputStream
    ioe.printStackTrace();
} catch (BackingStoreException bse) {
    // Exception whilst reading from the backing preferences store
    bse.printStackTrace();
}
जावा एसई 7 
OutputStream os = null;
try {
    os = ...;
    preferences.exportSubtree(os);
} catch (IOException ioe) {
    // Exception whilst writing data to the OutputStream
    ioe.printStackTrace();
} catch (BackingStoreException bse) {
    // Exception whilst reading from the backing preferences store
    bse.printStackTrace();
} finally {
    if (os != null) {
        try {
            os.close();
        } catch (IOException ignored) {}
    }
}

अपने बच्चे के नोड्स के साथ एकल नोड निर्यात करने के लिए:

जावा एसई 7 
try (OutputStream os = ...) {
    preferences.exportNode(os);
} catch (IOException ioe) {
    // Exception whilst writing data to the OutputStream
    ioe.printStackTrace();
} catch (BackingStoreException bse) {
    // Exception whilst reading from the backing preferences store
    bse.printStackTrace();
}
जावा एसई 7 
OutputStream os = null;
try {
    os = ...;
    preferences.exportSubtree(os);
} catch (IOException ioe) {
    // Exception whilst writing data to the OutputStream
    ioe.printStackTrace();
} catch (BackingStoreException bse) {
    // Exception whilst reading from the backing preferences store
    bse.printStackTrace();
} finally {
    if (os != null) {
        try {
            os.close();
        } catch (IOException ignored) {}
    }
}

प्राथमिकताएँ आयात करना

Preferences नोड्स को XML दस्तावेज़ से आयात किया जा सकता है। आयात का अर्थ Preferences के निर्यात की कार्यक्षमता के साथ संयोजन के रूप में इस्तेमाल किया जाना है, क्योंकि यह सही एक्सएमएल दस्तावेज़ बनाता है।

एक्सएमएल दस्तावेजों को याद होगा कि क्या वे उपयोगकर्ता या सिस्टम Preferences से निर्यात किए गए थे। इसलिए, वे अपने-अपने में आयात किया जा सकता है Preferences पेड़ फिर से, आप यह पता लगाने या पता वे कहाँ से आए बिना। स्थिर फ़ंक्शन स्वचालित रूप से यह पता लगा लेगा कि क्या XML दस्तावेज़ को उपयोगकर्ता या सिस्टम Preferences से निर्यात किया गया था और स्वचालित रूप से उन्हें उस पेड़ में आयात करेगा जिसे वे निर्यात किया गया था।

जावा एसई 7 
try (InputStream is = ...) {
    // This is a static call on the Preferences class
    Preferences.importPreferences(is);
} catch (IOException ioe) {
    // Exception whilst reading data from the InputStream
    ioe.printStackTrace();
} catch (InvalidPreferencesFormatException ipfe) {
    // Exception whilst parsing the XML document tree
    ipfe.printStackTrace();
}
जावा एसई 7 
InputStream is = null;
try {
    is = ...;
    // This is a static call on the Preferences class
    Preferences.importPreferences(is);
} catch (IOException ioe) {
    // Exception whilst reading data from the InputStream
    ioe.printStackTrace();
} catch (InvalidPreferencesFormatException ipfe) {
    // Exception whilst parsing the XML document tree
    ipfe.printStackTrace();
} finally {
    if (is != null) {
        try {
            is.close();
        } catch (IOException ignored) {}
    }
}

ईवेंट श्रोताओं को हटाना

इवेंट श्रोताओं को किसी भी Properties नोड से फिर से हटाया जा सकता है, लेकिन श्रोता का उदाहरण इसके लिए चारों ओर रखा जाना चाहिए।

जावा एसई 8 
Preferences preferences = Preferences.userNodeForPackage(getClass());

PreferenceChangeListener listener = evt -> {
    System.out.println(evt.getKey() + " got new value " + evt.getNewValue());
};
preferences.addPreferenceChangeListener(listener);

//
// later...
//

preferences.removePreferenceChangeListener(listener);
जावा एसई 8 
Preferences preferences = Preferences.userNodeForPackage(getClass());

PreferenceChangeListener listener = new PreferenceChangeListener() {
    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        System.out.println(evt.getKey() + " got new value " + evt.getNewValue());
    }
};
preferences.addPreferenceChangeListener(listener);

//
// later...
//

preferences.removePreferenceChangeListener(listener);

वही NodeChangeListener लिए लागू होता है।

प्राथमिकताएं प्राप्त करना

एक Preferences नोड का मान String , boolean , byte[] , double , float , int या long । सभी चालानों को एक डिफ़ॉल्ट मान प्रदान करना होगा, यदि निर्दिष्ट मान Preferences नोड में मौजूद नहीं है। 

Preferences preferences = Preferences.userNodeForPackage(getClass());

String someString = preferences.get("someKey", "this is the default value");
boolean someBoolean = preferences.getBoolean("someKey", true);
byte[] someByteArray = preferences.getByteArray("someKey", new byte[0]);
double someDouble = preferences.getDouble("someKey", 887284.4d);
float someFloat = preferences.getFloat("someKey", 38723.3f);
int someInt = preferences.getInt("someKey", 13232);
long someLong = preferences.getLong("someKey", 2827637868234L);

प्राथमिकताएँ मान सेट करना

मान नोड में Preferences संग्रहीत करने के लिए, putXXX() विधियों में से एक का उपयोग किया जाता है। एक Preferences नोड का मान String , boolean , byte[] , double , float , int या long । 

Preferences preferences = Preferences.userNodeForPackage(getClass());

preferences.put("someKey", "some String value");
preferences.putBoolean("someKey", false);
preferences.putByteArray("someKey", new byte[0]);
preferences.putDouble("someKey", 187398123.4454d);
preferences.putFloat("someKey", 298321.445f);
preferences.putInt("someKey", 77637);
preferences.putLong("someKey", 2873984729834L);

वरीयताओं का उपयोग करना

Preferences उपयोगकर्ता सेटिंग्स को संग्रहीत करने के लिए उपयोग की जा सकती हैं जो उपयोगकर्ता की व्यक्तिगत एप्लिकेशन सेटिंग्स को दर्शाती हैं, जैसे कि उनके संपादक फ़ॉन्ट, चाहे वे एप्लिकेशन को पूर्ण-स्क्रीन मोड में शुरू करना पसंद करते हैं, चाहे उन्होंने "फिर से न दिखाएं" चेकबॉक्स और चीजों को चेक किया हो उसके जैसा। 

public class ExitConfirmer {
    private static boolean confirmExit() {
        Preferences preferences = Preferences.userNodeForPackage(ExitConfirmer.class);
        boolean doShowDialog = preferences.getBoolean("showExitConfirmation", true); // true is default value

        if (!doShowDialog) {
            return true;
        }

        //
        // Show a dialog here...
        //
        boolean exitWasConfirmed = ...; // whether the user clicked OK or Cancel
        boolean doNotShowAgain = ...; // get value from "Do not show again" checkbox

        if (exitWasConfirmed && doNotShowAgain) {
            // Exit was confirmed and the user chose that the dialog should not be shown again
            // Save these settings to the Preferences object so the dialog will not show again next time
            preferences.putBoolean("showExitConfirmation", false);
        }

        return exitWasConfirmed;
    }

    public static void exit() {
        if (confirmExit()) {
            System.exit(0);
        }
    }
}


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow