Map.Entry : Comment l'utiliser ?

Question

Je travaille à la création d'une calculatrice. J'ai mis mes boutons dans un HashMap et quand je veux les ajouter à ma classe, qui prolonge JPanel Je ne sais pas comment récupérer les boutons de ma collection. J'ai donc trouvé sur internet 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 on peut utiliser Map.Entry -- qui est une interface, sans redéfinir Map.Entry Les fonctions de l'entreprise.

Answer 1

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 de devoir itérer sur Map.keySet() puis obtenir la valeur de chaque clé. 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, dites-le moi et je modifierai ma réponse.

Answer 2

Notez que vous pouvez également créer vos propres structures en utilisant une Map.Entry comme type principal, en utilisant son implémentation de base AbstractMap.SimpleEntry. Par exemple, si vous voulez avoir une liste ordonnée d'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. A partir de là, vous avez une liste de tuples. Très utile lorsque vous voulez des tuples ordonnés et qu'une Map de base n'est pas envisageable.

Answer 3

Ce code est mieux réécrit comme suit :

for( Map.Entry me : entrys.entrySet() )
{
    this.add( (Component) me.getValue() );
}

et c'est équivalent à :

for( Component comp : entrys.getValues() )
{
    this.add( comp );
}

Lorsque vous énumérez les entrées d'une carte, l'itération produit une série d'objets qui mettent en œuvre la fonction Map.Entry interface. 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 fait présuppose que vos Map est un HashMap et suppose également une connaissance du fonctionnement interne (détails de la mise en œuvre) de l'interface utilisateur. HashMap classe. Ce que l'on peut dire avec un peu plus de certitude, c'est que, quelle que soit la manière dont votre carte est mise en œuvre (qu'il s'agisse d'une classe HashMap ou autre chose,) si vous avez besoin à la fois de la clé et de la valeur de la carte, alors l'énumération des entrées sera plus efficace que l'énumération des clés et ensuite, pour chaque clé, le rappel de la carte afin de rechercher la valeur correspondante.

Answer 4

Une carte est une collection de paires Clé + Valeur, qui se visualise comme suit :

{[fooKey=fooValue],barKey=barValue],[quxKey=quxValue]}

L'interface Map offre quelques options pour accéder à cette collection : L'ensemble de clés [fooKey, barKey,quxKey] l'ensemble des valeurs [fooValue, barValue, quxValue] et enfin l'entrée Set [fooKey=fooValue],barKey=barValue],[quxKey=quxValue] .

Entry set est simplement une commodité pour itérer sur les paires clé-valeur dans la carte, la Map.Entry est la représentation de chaque paire clé-valeur. Une manière équivalente de faire votre dernière boucle serait :

for (String buttonKey: listbouton.keySet()) {
    this.add(listbouton.get(buttonKey)) ;
}

o

for (JButton button: listbouton.values()) {
    this.add(button) ;
}

Answer 5

Une carte est constituée de paires clé/valeur. Par exemple, dans votre code, une clé est "Add" et la valeur associée est JButton("+"). Une Map.Entry est une seule paire clé/valeur contenue dans la Map. Les deux méthodes les plus utilisées sont getKey() and getValue() . Votre code est tous les paires en un ensemble :

Set entrys = listbouton.entrySet() ;

et les parcourt par itération. Maintenant, il ne regarde que le valeur partie utilisant me.getValue() et les ajoute à votre PanneauCalcul

this.add((Component) me.getValue()) ;   //don't understand

Souvent, ce type de boucle (sur l'entrée Map.Entry) est utile si vous avez besoin d'examiner les éléments suivants les deux 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 tous les fichiers valeurs dans votre carte et ajoutez-les, par ex.

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 voulez préserver l'ordre des boutons, vous devriez utiliser un LinkedHashMap.