java parcourir Map.Entry: Comment l'utiliser?




set java (6)

Je travaille sur la création d'une calculatrice. Je pose mes boutons sur une collection HashMap et, lorsque je souhaite les ajouter à ma classe qui étend Jpanel, je ne sais pas comment 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 utiliser Map.Entry - qui est une interface - sans redéfinir les fonctions de Map.Entry .


Notez que vous pouvez également créer vos propres structures en utilisant un 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));

Etc. De là, vous avez une liste de tuples. Très utile lorsque vous voulez des n-uplets commandés et qu'une carte de base est une solution de rechange.


Ce code est mieux réécrit comme:

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

et cela équivaut à:

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

Lorsque vous énumérez les entrées d'une carte, l'itération génère une série d'objets qui implémentent l'interface Map.Entry . Chacun de ces objets contient une clé et une valeur.

Il est supposé être légèrement plus efficace d’énumérer les entrées d’une carte que d’énumérer ses valeurs, mais ce factoïde suppose que votre Map est un HashMap et suppose également une connaissance du fonctionnement interne (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 mise en œuvre (qu’il s’agisse d’un HashMap ou autre), si vous avez besoin à la fois de la clé et de la valeur de la carte, l’énumération des entrées est alors effectuée. être plus efficace que d’énumérer les clés puis d’appeler à nouveau la carte pour rechercher la valeur correspondante.


Hash-Map stocke la paire (clé, valeur) sous le type Map.Entry.Si vous savez que Hash-Map utilise Hash-Map lié (en cas de collision). Par conséquent, chaque nœud du compartiment de Hash-Map est de type Map.Entry. Ainsi, chaque fois que vous parcourez la carte de hachage, vous obtenez des nœuds de type Map.Entry.

Maintenant, dans votre exemple, lorsque vous parcourez Hash-Map, vous obtiendrez le type Map.Entry (qui est Interface), pour obtenir la clé et la valeur de cet objet de nœud Map.Entry, des méthodes fournies par l'interface, telles que getValue (), getKey () etc. Ainsi, conformément au code, dans votre objet, vous ajoutez tous les opérateurs JButtons viz (+, -, /, *, =).


Une carte est composée de paires clé / valeur. Par exemple, dans votre code, une clé est "Ajouter" et la valeur associée est JButton ("+"). Un Map.Entry est une paire unique clé / valeur contenue dans la carte. getKey() and getValue() sont ses deux méthodes les plus utilisées. Votre code regroupe toutes les paires dans un ensemble:

Set entrys = listbouton.entrySet() ;

et itère sur eux. Maintenant, il ne regarde que la partie valeur en utilisant me.getValue() et les ajoute à votre PanneauCalcul

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

Ce type de boucle (via Map.Entry) est souvent utile si vous devez examiner à la fois la clé et la valeur. Cependant, dans votre cas, vous n'utilisez pas les clés. Une version beaucoup plus simple consisterait simplement à obtenir toutes les valeurs de votre carte et à les ajouter. par exemple

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

Un dernier commentaire. L'ordre des itérations dans un HashMap est assez aléatoire. Les boutons seront donc ajoutés à votre PanneauCalcul dans un ordre semi-aléatoire. Si vous souhaitez conserver l'ordre des boutons, vous devez utiliser un LinkedHashMap.


Une carte est une collection de paires clé + valeur, qui se présente comme suit:

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

L'interface de la carte 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 l'entrée Set [fooKey=fooValue],barKey=barValue],[quxKey=quxValue] .

Le jeu d'entrées est simplement une commodité pour parcourir les paires de valeurs de clé dans la carte, le Map.Entry est la représentation de chaque paire de valeurs de clé. 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) ;
}

Map.Entry est une clé et sa valeur est combinée en une classe. Cela vous permet d'itérer sur Map.entrySet() au lieu d'avoir à itérer sur Map.keySet() , puis d'obtenir la valeur pour 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, faites le moi savoir et je modifierai ma réponse.





hashmap