web-dev-qa-db-fra.com

Map.Entry: Comment l'utiliser?

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

javadictionarycollectionshashmap
47
user1079425

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.

97
Paul

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 le Map.Entry interface. 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, quelle que soit la manière dont votre carte est mise en œuvre (qu’il s’agisse d’un HashMap ou de quelque chose d’autre,), vous avez besoin à la fois de la clé et de la valeur de la carte. les entrées seront plus efficaces que d'énumérer les clés, puis pour chaque clé, invoquer à nouveau la carte afin de rechercher la valeur correspondante.

2
Mike Nakis

Hash-Map stocke la paire (clé, valeur) sous le type Map.Entry.Si vous savez que Hash-Map utilise un hachage-carte lié (en cas de collision). Par conséquent, chaque Node dans le 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 cette carte.Entry Node Object, 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 (+, -, /, *, =).

1
bharatj

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

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

L’interface Map offre quelques options pour accéder à cette collection: The Key set [fooKey, barKey,quxKey], la valeur définie [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, 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) ;
}
1
markdsievers

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. 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 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 les deux la clé et la valeur. Cependant, dans votre cas, vous n'utilisez pas les clés. Une version beaucoup plus simple consisterait simplement à obtenir tous 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.

1
user949300

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.

1
jytou

l'interface Map.Entry nous aide à itérer une classe Map

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());
        }
    }
}
0
Kamran