Java Language
गुण वर्ग

परिचय

वाक्य - विन्यास

• गुण फ़ाइल में:
• कुंजी = मान
• #टिप्पणी

टिप्पणियों

संपत्तियों को लोड कर रहा है

अपने आवेदन के साथ बंडल की गई फ़ाइल को लोड करने के लिए:

public class Defaults {

    public static Properties loadDefaults() {
        try (InputStream bundledResource =
            Defaults.class.getResourceAsStream("defaults.properties")) {

            Properties defaults = new Properties();
            defaults.load(bundledResource);
            return defaults;
        } catch (IOException e) {
            // Since the resource is bundled with the application,
            // we should never get here.
            throw new UncheckedIOException(
                "defaults.properties not properly packaged"
                + " with application", e);
        }
    }

}

संपत्ति फाइलें कैविएट: अनुगामी व्हॉट्सएप

इन दो संपत्ति फ़ाइलों पर एक करीब से नज़र डालें जो पूरी तरह से समान हैं:

सिवाय इसके कि वे वास्तव में समान नहीं हैं:

(स्क्रीनशॉट नोटपैड ++ से हैं)

पिछली श्वेत रिक्ति का मूल्य संरक्षित है के बाद से lastName होगा "Smith" पहले मामले में और "Smith " दूसरे मामले में।

बहुत कम ही ऐसा होता है जो उपयोगकर्ता अपेक्षा करते हैं और एक और केवल अनुमान लगा सकते हैं कि यह Properties वर्ग का डिफ़ॉल्ट व्यवहार क्यों है। हालाँकि इस समस्या को ठीक करने वाले Properties का एक उन्नत संस्करण बनाना आसान है। निम्न वर्ग, ट्राइम्डप्रोपरेट्स , बस यही करता है। यह मानक गुण वर्ग के लिए एक ड्रॉप-इन प्रतिस्थापन है।

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.Map.Entry;
import java.util.Properties;

/**
 * Properties class where values are trimmed for trailing whitespace if the
 * properties are loaded from a file.
 *
 * <p>
 * In the standard {@link java.util.Properties Properties} class trailing
 * whitespace is always preserved. When loading properties from a file such
 * trailing whitespace is almost always <i>unintentional</i>. This class fixes
 * this problem. The trimming of trailing whitespace only takes place if the
 * source of input is a file and only where the input is line oriented (meaning
 * that for example loading from XML file is <i>not</i> changed by this class).
 * For this reason this class is almost in all cases a safe drop-in replacement
 * for the standard <tt>Properties</tt>
 * class.
 *
 * <p>
 * Whitespace is defined here as any of space (U+0020) or tab (U+0009).
 * * 
 */
public class TrimmedProperties extends Properties {

    /**
     * Reads a property list (key and element pairs) from the input byte stream.
     * 
     * <p>Behaves exactly as {@link java.util.Properties#load(java.io.InputStream) }
     * with the exception that trailing whitespace is trimmed from property values
     * if <tt>inStream</tt> is an instance of <tt>FileInputStream</tt>.
     * 
     * @see java.util.Properties#load(java.io.InputStream) 
     * @param inStream the input stream.
     * @throws IOException if an error occurred when reading from the input stream.
     */
    @Override
    public void load(InputStream inStream) throws IOException {
        if (inStream instanceof FileInputStream) {
            // First read into temporary props using the standard way
            Properties tempProps = new Properties();
            tempProps.load(inStream);
            // Now trim and put into target
            trimAndLoad(tempProps);
        } else {
            super.load(inStream);
        }
    }

    /**
     * Reads a property list (key and element pairs) from the input character stream in a simple line-oriented format. 
     * 
     * <p>Behaves exactly as {@link java.util.Properties#load(java.io.Reader)}
     * with the exception that trailing whitespace is trimmed on property values
     * if <tt>reader</tt> is an instance of <tt>FileReader</tt>.
     * 
     * @see java.util.Properties#load(java.io.Reader) }
     * @param reader the input character stream.
     * @throws IOException if an error occurred when reading from the input stream.
     */
    @Override
    public void load(Reader reader) throws IOException {
        if (reader instanceof FileReader) {
            // First read into temporary props using the standard way
            Properties tempProps = new Properties();
            tempProps.load(reader);
            // Now trim and put into target
            trimAndLoad(tempProps);
        } else {
            super.load(reader);
        }
    }

    private void trimAndLoad(Properties p) {
        for (Entry<Object, Object> entry : p.entrySet()) {
            if (entry.getValue() instanceof String) {
                put(entry.getKey(), trimTrailing((String) entry.getValue()));
            } else {
                put(entry.getKey(), entry.getValue());
            }
        }
    }

    /**
     * Trims trailing space or tabs from a string.
     *
     * @param str
     * @return
     */
    public static String trimTrailing(String str) {
        if (str != null) {
            // read str from tail until char is no longer whitespace
            for (int i = str.length() - 1; i >= 0; i--) {
                if ((str.charAt(i) != ' ') && (str.charAt(i) != '\t')) {
                    return str.substring(0, i + 1);
                }
            }
        }
        return str;
    }
}

XML के रूप में बचत गुण

एक XML फ़ाइल में भंडारण गुण

जिस तरह से आप गुण फाइलों को XML फ़ाइलों के रूप में संग्रहीत करते हैं, वह उसी तरह से है जिस तरह से आप उन्हें .properties फ़ाइलों के रूप में संग्रहीत करेंगे। store() का उपयोग करने के बजाय आप storeToXML() उपयोग करेंगे।

public void saveProperties(String location) throws IOException{
    // make new instance of properties
    Properties prop = new Properties();
    
    // set the property values
    prop.setProperty("name", "Steve");
    prop.setProperty("color", "green");
    prop.setProperty("age", "23");
    
    // check to see if the file already exists
    File file = new File(location);
    if (!file.exists()){
        file.createNewFile();
    }
    
    // save the properties
    prop.storeToXML(new FileOutputStream(file), "testing properties with xml");
}

जब आप फ़ाइल खोलेंगे तो यह इस तरह दिखेगा।

XML फ़ाइल से गुण लोड हो रहा है

अब इस फ़ाइल को उन properties रूप में load() करने के लिए जिन्हें आपको load() बजाय loadFromXML() को कॉल करने की आवश्यकता है जिसे आप नियमित .propeties फ़ाइलों के साथ उपयोग करेंगे।

public static void loadProperties(String location) throws FileNotFoundException, IOException{
    // make new properties instance to load the file into
    Properties prop = new Properties();
    
    // check to make sure the file exists
    File file = new File(location);
    if (file.exists()){
        // load the file
        prop.loadFromXML(new FileInputStream(file));
        
        // print out all the properties
        for (String name : prop.stringPropertyNames()){
            System.out.println(name + "=" + prop.getProperty(name));
        }
    } else {
        System.err.println("Error: No file found at: " + location);
    }
}

जब आप इस कोड को चलाते हैं तो आपको कंसोल में निम्नलिखित मिलेंगे:

age=23
color=green
name=Steve