Classe de propriétés en Java

Une classe de propriétés en Java est une classe avec un objet spécial présent dans la classe de propriétés, qui contient l'ensemble de données persistantes lié à l'objet à diffuser. La classe Properties est une sous-classe de Hashtable et est utilisée pour conserver la série entière de données sous la forme de la clé sous forme de chaîne et sa valeur sous la forme d'une chaîne. Une très bonne caractéristique de cette classe est qu’elle renverra la valeur qui ne satisfait pas les valeurs fournies avec une clé. Le concept de threads multiples se satisfait également facilement de la classe de propriétés.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Constructeurs

Il existe deux types de constructeurs dans la classe Properties, qui sont les suivants :

# Properties() en tant que constructeur

Le constructeur Propriétés() est un constructeur utilisé pour créer un objet de propriétés sans valeurs par défaut.

# Propriétés (Propriétés par défaut) en tant que constructeur

Properties(Properties Default) crée un objet qui utilise ses valeurs par défaut comme propDefault. Mais dans tous les cas, qu'il s'agisse de Properties() en tant que constructeur ou de Properties() en tant que constructeur, la liste des propriétés sera uniquement vide.

Remarque : La variable d'instance décrite contient une liste de propriétés par défaut liée à l'objet Properties au sein de la classe Properties.

Méthodes

Java Properties est un type de classe qui comprend les méthodes suivantes :

• Chaîne getProperty(Clé de chaîne)
• String getProperty(String key, String defaultProperty)
• voidList(PrintStream streamOut)
• voidList(PrintWriter streamOut)
• voidload(InputStream streamIn) lève une exception IO
• Noms des propriétés d'énumération()
• ObjectSetProerty (clé de chaîne, StringValue)
• magasin vide (flux de sortie streamOut, description de la chaîne)

# Objet setProperty (clé de chaîne, valeur de chaîne)

Une valeur est associée à la clé, qui renvoie la valeur précédente liée à la clé ou renvoie null s'il n'y a pas d'association entre la paire clé et valeur.

# void load (InputStream streamIn) lève une exception IO

Streamln, en tant que paramètre passé, est lié au flux d'entrée et obtient une entrée avec une liste des listes de propriétés.

#Enumeration propertyNames()

Une énumération et une description des clés définies sont renvoyées, y compris les clés qui composent également la liste de propriétés avec son contenu et son explication.

#String getProperty(Clé)

Le constructeur transmis doit être une clé avec la valeur associée sous forme de chaîne, et si un objet nul est renvoyé, alors soit les clés ne sont pas présentes dans la liste, soit elles ne sont même pas présentes dans aucune liste de propriétés par défaut.

# String getProperty(StringKey, String defaultProperty)

Le comportement est le même que celui de String getProperty, outre le fait qu'il renvoie également la propriété par défaut. Peu importe que la clé soit présente dans la propriété ou dans la liste par défaut.

# liste vide (PrintStream, streamOut)

Le paramètre streamOut est lié au flux de sortie et renvoie la valeur dès l'envoi de la liste de propriétés.

# liste vide (PrintWriter streamOut)

Le paramètre streamOut lié au flux de sortie est renvoyé dès que la liste de propriétés est passée, ce qui signifie que son comportement est le même que celui d'impression avec un peu plus de privilèges

# void store (OutputStream streamOut, Description)

streamOut lié au outputStream écrit la liste des propriétés ; cette chaîne écrira avec la description spécifiée une fois écrite.

Remarque : Les méthodes définies dans la classe de propriétés sont héritées de hashTable ; toutes ces méthodes prennent en charge l'objet propriétés de la classe de propriétés et définissent certaines méthodes de classe héritées.

Exemples de classe de propriétés en Java

Différents exemples sont mentionnés ci-dessous :

Exemple n°1

Programme pour démontrer les méthodes et les constructeurs associés à la classe Properties.

import java.util.*;
public class PropertiesExmpl
{
public static void main(String arg[])
{
Properties ex = new Properties();
Set url;
String str;
ex.put("ide", "ide.educba.org");
ex.put("contribution", "contribution.educba.org");
ex.put("articles", "articles.contribution.educba.org");
url = ex.keySet();
Iterator itr = url.iterator();
while(itr.hasNext())
{
str = (String)itr.next();
System.out.println("The url for " + str +
" is " + ex.getProperty(str));
}
System.out.println();
str = ex.getProperty("article", "not found");
System.out.println("This is the respective url for the article " + str);
}
}

Sortie :

Exemple n°2

Programme pour démontrer la méthode de liste associée à la liste Propriétés.

import java.util.*;
public class PropertiesList
{
public static void main(String arg[])
{
Properties ex = new Properties();
Set url;
String str;
ex.put("ide", "ide.educba.org");
ex.put("contribution", "contribution.educba.org");
ex.put("article", "article.educba.org");
ex.list(System.out);
}
}

Sortie :

Exemple #3

Programme pour utiliser la méthode PrintWriter présente dans la méthode de liste de propriétés de la classe de propriétés.

import java.io.PrintWriter;
import java.util.*;
public class PropertiesDem1
{
public static void main(String arg[])
{
Properties ex = new Properties();
PrintWriter writer = new PrintWriter(System.out);
ex.put("ide", "ide.educba.org");
ex.put("contribution", "contribution.educba.org");
ex.put("article", "article.educba.org");
ex.list(writer);
writer.flush();
}
}

Sortie :

Exemple n°4

Programme pour énumérer et démontrer les valeurs présentes dans la liste des propriétés.

import java.util.*;
public class PropertiesDem2
{
public static void main(String arg[])
{
Properties exmpl = new Properties();
Set str;
String s;
exmpl.put("ide", "ide.educba.org");
exmpl.put("contribution", "contribution.educba.org");
exmpl.put("artcle", "article.educba.org");
Enumeration name = exmpl.propertyNames();
System.out.println(name.nextElement());
System.out.println(name.nextElement());
System.out.println(name.nextElement());
}
}

Sortie :

Example #5

Program to set the value with the properties object of properties class.

import java.util.*;
public class PropertiesDem4
{
public static void main(String arg[])
{
Properties exmpl3 = new Properties();
exmpl3.put("ide", "ide.educba.org");
exmpl3.put("contribute", "contribute.educba.org");
exmpl3.setProperty("article", "article.educba.org");
System.out.println(exmpl3);
}
}

Output:

Example #6

Program to demonstrate the properties class method of loading the data set.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.*;
public class PropertiesDem8
{
public static void main(String arg[]) throws IOException
{
Properties exmpl4 = new Properties();
String s = "ide = ide.educba.org";
FileOutputStream out = new FileOutputStream("properties.txt");
FileInputStream in = new FileInputStream("properties.txt");
out.write(s.getBytes());
exmpl4.load(in);
exmpl4.list(System.out);
}
}

Output:

Example #7

Program to demonstrate the Properties class associated with the object of the properties class and then load the values within the properties class.

import java.io.IOException;
import java.io.StringReader;
import java.util.*;
public class PropertiesDem9
{
public static void main(String arg[]) throws IOException
{
Properties ex = new Properties();
String s = "ide = ide.educba.org";
StringReader reader = new StringReader(s);
ex.load(reader);
ex.list(System.out);
}
}

Output:

Example #8

The program stores the properties’ objects and key values in the properties class.

import java.io.IOException;
import java.io.StringReader;
import java.util.*;
public class PropertiesDem5
{
public static void main(String arg[]) throws IOException
{
Properties ex = new Properties();
ex.put("ide", "ide.educba.org");
ex.put("contribution", "contribution.educba.org");
ex.put("article", "article.edu.cba.org");
ex.store(System.out, "Demo for all Properties class");
}
}

Output:

Advantages of Properties class in Java:

• It is easier for end-users to get the maintained form of a list specifying the required value and associated key.
• Return of default value is a very good property for specification and kind of notification if the key and value pair don’t get matched, it will return the null or default value associated.
• There is no need for external synchronization in multi-threading, which shares object properties within the property class.

Conclusion – Properties Class in Java

The properties class has an instance variable within the object of the properties class, which is used to get the return value and to get the associated default value with the streaming also associated with it. Therefore, the properties class in Java is pivotal in the methods and constructors present.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!