Cartographie.Entrée: Comment l'utiliser?
Je travaille sur la création d'une calculatrice .. Je mets mes boutons sur une collection HashMap et quand je veux les ajouter à ma classe qui étend Jpanel, je ne sais pas comment puis-je obtenir les boutons de ma collection. J'ai donc trouvé Sur le net les 2 dernières lignes de mon code, mais je ne connais pas leur signification.
Voici mon code :
import java.awt.Component;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.swing.JButton;
import javax.swing.JPanel;
public class PanneauCalcul extends JPanel {
private HashMap<String, JButton> listbouton = new HashMap<String, JButton>() ;
public PanneauCalcul() {
for(int i = 0; i < 10; i ++) {
listbouton.put("num" + i, new JButton("" + i)) ;
}
listbouton.put("add", new JButton("+")) ;
listbouton.put("soustract", new JButton("-")) ;
listbouton.put("multiply", new JButton("x")) ;
listbouton.put("divise", new JButton("/")) ;
listbouton.put("equal", new JButton("=")) ;
Set entrys = listbouton.entrySet() ;
Iterator iter = entrys.iterator() ;
while(iter.hasNext()) {
Map.Entry me = (Map.Entry)iter.next(); //don't understand
this.add((Component) me.getValue()) ; //don't understand
}
EcouteCalcul ecout = new EcouteCalcul(this) ;
}
}
Je ne comprends pas comment pouvons-nous utiliser Map.Entry - qui est une interface-sans redéfinir les fonctions de Map.Entry.
7 answers
Map.Entry est une clé et sa valeur combinées en une seule classe. Cela vous permet d'itérer sur Map.entrySet() au lieu d'avoir à parcourir Map.keySet(), alors la valeur de chaque touche. Une meilleure façon d'écrire ce que vous avez est:
for (Map.Entry<String, JButton> entry : listbouton.entrySet())
{
String key = entry.getKey();
JButton value = entry.getValue();
this.add(value);
}
Si ce n'était pas clair, faites-le moi savoir et je modifierai ma réponse.
Ce code est mieux réécrit comme:
for( Map.Entry me : entrys.entrySet() )
{
this.add( (Component) me.getValue() );
}
Et il est équivalent à:
for( Component comp : entrys.getValues() )
{
this.add( comp );
}
Lorsque vous énumérez les entrées d'une carte, l'itération donne une série d'objets qui implémentent l'interface Map.Entry. Chacun de ces objets contient une clé et une valeur.
Il est censé être légèrement plus efficace d'énumérer les entrées d'une carte que d'énumérer ses valeurs, mais ce factoid suppose que votre Map est un HashMap, et suppose également la connaissance de l'intérieur fonctionnement (détails d'implémentation) de la classe HashMap. Ce qui peut être dit avec un peu plus de certitude, c'est que peu importe la façon dont votre carte est implémentée, (que ce soit un HashMap ou autre chose,) si vous avez besoin à la fois de la clé et de la valeur de la carte, alors énumérer les entrées sera plus efficace que d'énumérer les clés, puis pour chaque clé
Une carte est constituée de paires clé/valeur. Par exemple, dans votre code, une clé est "Ajouter" et la valeur associée est JButton("+"). cartographie.L'entrée est une seule paire clé/valeur contenue dans la carte. Ses deux méthodes les plus utilisées sont getKey() and getValue(). Votre code obtient tous les paires dans un ensemble:
Set entrys = listbouton.entrySet() ;
Et itère sur eux. Maintenant, il ne regarde que la partie value en utilisant me.getValue() et les ajoute à votre PanneauCalcul
this.add((Component) me.getValue()) ; //don't understand
Souvent ce type de boucle (sur la carte.Entrée) a du sens si vous devez regarder à la fois la clé et la valeur. Cependant, dans votre cas, vous n'utilisez pas les clés, donc une version beaucoup plus simple serait d'obtenir toutes les valeurs dans votre carte et de les ajouter. par exemple
for (JButton jb:listbouton.values()) {
this.add(jb);
}
Un dernier commentaire. L'ordre d'itération dans un HashMap est assez aléatoire. Ainsi, les boutons seront ajoutés à votre PanneauCalcul dans un ordre semi-aléatoire. Si vous souhaitez conserver l'ordre des boutons, vous devez utiliser une LinkedHashMap.
Une carte est une collection de paires Clé + Valeur, qui est visualisée comme ceci:
{[fooKey=fooValue],barKey=barValue],[quxKey=quxValue]}
L'interface Map permet quelques options pour accéder à cette collection: Le jeu de clés [fooKey, barKey,quxKey], le jeu de Valeurs [fooValue, barValue, quxValue] et enfin le Jeu d'entrées [fooKey=fooValue],barKey=barValue],[quxKey=quxValue].
Le jeu d'entrées est simplement pratique pour parcourir les paires clé-valeur de la carte, la carte.Entry est la représentation de chaque paire clé-valeur. Une façon équivalente de faire votre dernière boucle serait:
for (String buttonKey: listbouton.keySet()) {
this.add(listbouton.get(buttonKey)) ;
}
Ou
for (JButton button: listbouton.values()) {
this.add(button) ;
}
Hash-Map stocke la paire (clé,valeur) en tant que carte.Entrée Type.As vous savez que Hash-Map utilise une Hash-Map liée (en cas de collision). Par conséquent, chaque nœud dans le compartiment de Hash-Map est de Type Map.Entrée. Donc, chaque fois que vous parcourez la carte de hachage, vous obtiendrez des nœuds de Type Map.Entrée.
Maintenant, dans votre exemple, lorsque vous parcourez la carte de hachage, vous obtiendrez la carte.Type d'entrée (Qui est Interface), Pour obtenir la clé et la valeur à partir de cette Carte.Objet de nœud d'entrée, interface fournie des méthodes comme getValue (), getKey () etc. Donc, selon le code, dans votre objet, vous ajoutez tous les opérateurs JButtons à savoir (+,-,/,*,=).
Carte.L'interface d'entrée nous aide à itérer une classe de carte
Vérifiez cet exemple simple:
public class MapDemo {
public static void main(String[] args) {
Map<Integer,String> map=new HashMap();
map.put(1, "Kamran");
map.put(2, "Ali");
map.put(3, "From");
map.put(4, "Dir");
map.put(5, "Lower");
for(Map.Entry m:map.entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
}
Notez que vous pouvez également créer vos propres structures à l'aide d'une Carte.Entrée en tant que type principal, en utilisant son implémentation de base AbstractMap.SimpleEntry. Par exemple, si vous voulez avoir une liste ordonnée des entrées, vous pouvez écrire:
List<Map.Entry<String, Integer>> entries = new ArrayList<>();
entries.add(new AbstractMap.SimpleEntry<String, Integer>(myStringValue, myIntValue));
Et ainsi de suite. À partir de là, vous avez une liste de tuples. Très utile lorsque vous voulez des tuples commandés et une carte de base est un no-go.