Cours de paire pour Java et non pour Javafx

Voici une liste de noms de fruits et de leurs couleurs extérieures: BlackBerry => Bleu foncé-noir
banane => jaune
pastèque => vert
raisin => rose
Strawberry => rouge

Chaque ligne est une paire de clé / valeur. Le nom d'un fruit est la clé, et sa couleur est sa valeur. Il est possible d'avoir une autre liste où les clés sont des nombres ou les valeurs sont des nombres, ou les deux clés et valeurs sont des nombres. Dans la liste ci-dessus, les clés sont des chaînes et les valeurs sont des chaînes.

Javafx est une bibliothèque Java qui n'est pas installée avec Java. Il a une classe appelée paire, à utiliser pour gérer les paires. Le problème avec l'utilisation de la classe de paire avec Java, c'est que le programmeur doit toujours installer Javafx sur Java et apprendre à utiliser Javafx.

Ce problème peut être évité en utilisant la fonction d'entrée en Java proprement. Les paires sont appelées entrées de carte (ou simplement entrées) en Java proprement. Cet article explique comment gérer les entrées en Java, par opposition à la façon de gérer les paires dans Javafx, avec tous les problèmes d'utilisation de Javafx. Vous vous retrouvez avec les mêmes résultats. Les entrées sont les paires de clés / valeur en Java. L'équivalent de la classe de paires dans Javafx est l'abstractMap.Classe SimpleEntry à Java, qui est explorée dans cet article. La classe abstractmap.SimpleEntry est dans le java.user.* package, qui doit être importé.

Contenu de l'article

• Classe AbstractMap.Présentation de SimpleEntry
• Construire une paire
• AbstractMap.Méthodes simples
• Construire une carte personnalisée
• Conclusion

Classe AbstractMap.Présentation de SimpleEntry

Cette classe crée une paire. Une paire est le code ayant une clé et sa valeur correspondante.

Constructeurs

Cette classe a deux constructeurs et six méthodes. Les syntaxes complètes pour les constructeurs sont

public SimpleEntry (Key, Vale V)

et

public SimpleEntry (carte.Entrée entrée)

Méthodes

Sur les six méthodes, seuls quatre seront illustrés dans cet article. Les syntaxes complètes pour les quatre méthodes sont:

public k gentkey ()
public v getValue ()
public v setValue (Vale V)

et

public String toString ()

Construire une paire

Dans Java proprement dit, une paire est une entrée de carte. Le programme suivant utilise le premier constructeur ci-dessus pour construire une paire:

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
AbstractMap.SimpleEntry paire = new AbstractMap.SimpleEntry("BlackBerry", "Dark Blue-Black");

Le type de la clé est la chaîne, et le type de valeur est également une chaîne. Le programme suivant montre comment une paire est construite à partir d'une autre paire, en utilisant le deuxième constructeur ci-dessus:

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
AbstractMap.SimpleEntry paire1 = new AbstractMap.SimpleEntry("BlackBerry", "Dark Blue-Black");
AbstractMap.SimpleEntry paire2 = new AbstractMap.SimpleEntry(paire1);

La clé / valeur de Pair2 est «BlackBerry» / «Dark Blue-Black», qui est la même que celle de Pair1.

AbstractMap.Méthodes simples

Sur les six méthodes, seuls quatre seront illustrés ici.

public k gentkey ()

Après avoir créé une paire, sa clé peut être renvoyée, comme indiqué dans le segment de code suivant:

AbstractMap.SimpleEntry paire = new AbstractMap.SimpleEntry("BlackBerry", "Dark Blue-Black");
String kstr = paire.Obtenir la clé();
Système.dehors.println (kstr);

Dans ce cas, le type de retour est une chaîne et c'est: BlackBerry.

public v getValue ()

Après avoir créé une paire, sa valeur peut être renvoyée comme indiqué dans le segment de code suivant:

AbstractMap.SimpleEntry paire = new AbstractMap.SimpleEntry("BlackBerry", "Dark Blue-Black");
String VSTR = paire.getValue ();
Système.dehors.println (vstr);

Dans ce cas, le type de retour est une chaîne et il est: "Blue noir foncé".

public v setValue (Vale V)

La valeur d'une paire peut être définie, mais sa clé ne peut pas être définie. Dans le segment de code suivant, la valeur de la paire est modifiée.

AbstractMap.SimpleEntry paire = new AbstractMap.SimpleEntry("BlackBerry", "Dark Blue-Black");
paire.setValue ("Green-blanc clair");
public String toString ()

Cela renvoie une représentation de chaîne de la clé et de la valeur de la paire. Le code suivant illustre ceci:

AbstractMap.SimpleEntry paire = new AbstractMap.SimpleEntry("BlackBerry", "Dark Blue-Black");
String kvstr = paire.toString ();
Système.dehors.println (kvstr);

La sortie est:

mûre = noir bleu foncé

où = sépare la clé de la valeur.

Construire une carte personnalisée

L'entrée de carte (paire) n'est pas vraiment censée être utilisée avec un hashtable ou un hashmap ou une structure de données de carte similaire. Il est en fait destiné à être utilisé pour créer une structure de données de carte personnalisée. Il est facile de créer une structure de données de carte personnalisée: recherchez simplement une structure de données de liste telle que l'arrayList, dont les membres (champs et méthodes) sont intéressants; Et laissez les paires être les éléments de la liste.

La syntaxe pour créer un objet ArrayList vide est:

Liste des tableaux Al = Nouveau ArrayList();

où al est l'objet ArrayList. La syntaxe pour ajouter un élément (paire) à une arraylist, est

Al.Ajouter (e e)

Une méthode Java Main () avec une carte personnalisée appelée Al, peut avoir les paires suivantes:

AbstractMap.SimpleEntry paire1 = new AbstractMap.SimpleEntry("BlackBerry", "Dark Blue-Black");
AbstractMap.SimpleEntry paire2 = new AbstractMap.SimpleEntry("banane", "jaune");
AbstractMap.SimpleEntry paire3 = new AbstractMap.SimpleEntry("pastèque", "vert");
AbstractMap.SimpleEntry paire4 = new AbstractMap.SimpleEntry("raisin", "rose");
AbstractMap.SimpleEntry paire5 = new AbstractMap.SimpleEntry("Strawberry", "Red");

Le code pour créer l'objet ArrayList et ajouter les paires serait:

Liste des tableaux> al = nouvelle arraylist> ();
Al.ajouter (paire1); Al.ajouter (paire2); Al.ajouter (paire3); Al.ajouter (paire4); Al.ajouter (paire5);

Le code pour imprimer les paires de clés / valeur de la carte personnalisée serait:

pour (int i = 0; iSystème.dehors.println (Al.obtenir (i).getKey () + "=>" + al.obtenir (i).getValue ());

La sortie est:

BlackBerry => noir bleu foncé
banane => jaune
pastèque => vert
raisin => rose
Strawberry => rouge

Conclusion

Une paire, appelée Map-Entry en Java proprement dit, est le code ayant une clé et sa valeur correspondante. Les syntaxes pour construire une paire sont:

public SimpleEntry (Key, Vale V)
public SimpleEntry (carte.Entrée entrée)

Un exemple de création d'un objet de paire est:

AbstractMap.SimpleEntry paire1 = new AbstractMap.SimpleEntry("BlackBerry", "Dark Blue-Black");

La classe abstractmap.SimpleEntry pour créer une paire est dans le java.user.* package, qui doit être importé. L'abstractmap.La classe SimpleEntry a des méthodes. Les syntaxes pour quatre dont sont:

public k gentkey ()
public v getValue ()
public v setValue (Vale V)
public String toString ()

Le segment de code suivant est la création d'une carte personnalisée où les paires du même type sont les éléments:

Liste des tableaux> al = nouvelle arraylist> ();
Al.ajouter (paire1); Al.ajouter (paire2); Al.ajouter (paire3); Al.ajouter (paire4); Al.ajouter (paire4);

Chrys