TABLE DE HACHAGE SIMILAIRE À LA HASHMAP JAVA1.4

Commentaire de attonnnn le 12/11/2006 09:57:00

Une HashMap permet de d'associer dans une "map" des objets deux à deux : une clé et une valeur.
Dans cette implémentation, la clé est de type String (afin de ne pas imposer une fonction de hachage à la clé...) et la valeur de n importe quel type.

En flash les tableaux peuvent déja faire office de hashmap :
array["toto"] = new Toto();
mais il est alors impossible de savoir le nombre d'éléments ds le tableau, d'itérer sur ces éléments...

En passant de Java a Flash c est la classe qui m'a fait le plus défaut au prime abord j ai donc trouvé utile de la simuler.

Pour ma part je m en sert pour ranger différents objets implémentant une meme interface.
Je peux alors itérer dessus pour lancer une fonction sur chaque objet et pouvoir récuperer un objet précis lorsque j'en ai besoin.

et il y a surtout "l'habitude" de travailler avec cette classe ;)

voila j espere que c etait clair

Commentaire de attonnnn le 12/11/2006 18:35:49

tout de suite :p

voici une des nombreuses utilisation que j'en fait

/****************************************************************/
class MediaTypes{

private var mediaTypes;

public function MediaTypes(main:MovieClip){
mediaTypes = new HashMap();

var imgDisplayer = new ImageDisplayer(main);
mediaTypes.put("image", imgDisplayer );
main.addChildAt( imgDisplayer, 0 );

var videoDisplayer = new VideoDisplayer(main);
mediaTypes.put("video", videoDisplayer );
main.addChildAt( videoDisplayer, 0 );

var noMedia = new NoMedia(main);
mediaTypes.put("none", noMedia );
}

public function getMedia(media:String){
if(mediaTypes.get(media) == undefined || mediaTypes.get(media) == null)
trace("Error : "+media+" is not a media");
return mediaTypes.get(media);
}

public function hideAll(){
var medias:Array = mediaTypes.values();
for(var i=0 ; i < medias.length ; ++i)
medias[i].hide();
}
}
/****************************************************************/

Explication :
Ce code ne signifie pas grand chose dans la mesure ou il fait partie d'un projet de plus grande envergure mais je vais essayer d'expliquer l'utilité.

J'ai dans un fichier XML un attribut "media" pouvant prendre les valeurs "image" "video" ou "none"

A l initialisation de MediaTypes, je remplis ma hashmap avec les differents médias présents. Toutes les implementations d'un média héritent d une interface et possède une méthode hide() afin de pouvoir les cacher ou les montrer selon ce que dicte le fichier XML.

Je peux alors récupérer un média en temps constant, et cacher tous les médias présents. Dans une future implémentation ne seront créés que les médias requis lors de la lecture du XML (ca ne regarde que moi ca :p)

Le principal avantage ici est la maintenabilité. Si je veux ajouter un nouveau média, il suffit juste d'écrire la classe implémentant l'interface et la mettre dans la table :D.

je ne sais pas si j ai été clair mais les programmeurs Java comprendront tout de suite l'utilité de cette classe ! C'est une "maniere" de coder :)

Commentaire de top30 le 14/11/2006 21:55:46

interface iMediaObj {
   public function hide():Void ;
   public function show():Void ;
}

class MediaType extends String {
   public static var IMAGE :MediaType= "image" ;
   public static var VIDEO :MediaType= "video" ;
   public static var NONE  :MediaType= "none" ;

   public function MediaType( type :String ){
      super(type) ;
   }
}

class MediaList extends Array {
   public function addItem ( type :MediaType, objMedia :iMediaObj ):Number{
      push( {type:type, media:objMedia } ) ;
      return length-1 ;
  }
  
  public function getItemAt( i :Number ) :iMediaObj {
      return this[i].media ;
  }

  public function removeItem( objMedia :iMediaObj ) {
      // ;
  }
  
  public function removeItemAt( i :Number ) {
      // ;
  }

  public function getList( type :MediaType ):Array{
      var list :Array= [];
      if( !type ) {
          for( var i :Number= 0 ; i<length ;i++ ) {
             list.push( this[i].media ) ;
          }
       } else {
          if ( this[i].type== type ) list.push( this[i].media ) ;
       }
       return list ;
    }  
}  

class MediaTypeManager {
   private var mediaList :MediaList;
  
   public function MediaTypeManager ( main :MovieClip ){
      mediaList= new MediaList() ;
      mediaList.addItem( MediaType.IMAGE, new ImageDisplayer(main) );
      mediaList.addItem( MediaType.VIDEO, new VideoDisplayer(main) );
      mediaList.addItem( MediaType.NONE, new VideoDisplayer(main) );  
   }

   public function getMedia( type :String ):Media{
      if ( medias[name]== null ) {
          trace ( name + " n'est pas un Media" ) ;
      } else {
          return medias[name] ;
      }
   }

   public function hideAll():Void{
      var a :Array= mediaList.getList(null) ;
      for( var i in a) a[i].hide() ;
   }
}


Typage du type en dure, possibilité de connaitre la "longueur" selon chaque "type"...
Car perso moi, j'ai pas bien compris à quoi ca sert le concept "HashMap"

Commentaire de attonnnn le 14/11/2006 22:30:10

L'avantage se situe sur des Maps possédant de nombreuses entrées
- La récupération d'une valeur (par get()) ou le test d une clé se fait en temps contant quelle que soit la taille de la Map
- L'ajout aussi bien sur en tps constant
- La récupération de la liste des clés (keys())peut se faire en temps constant (si l'on ne renvoit pas une copie du tableau par sécurité avec slice(), a vous de voir).
- La suppression d une clé ne dépend que du temps de la méthode Array.splice().

Le gros defaut de ton code c'est la recherche de l'élément qui itère tout le tableau.
De plus tu casses la genericité du code en specifiant le type de la clé et la valeur associée.

Mon exemple n'etait peut etre pas bien choisit (Dsl c'etait le premier que j avais sous la main ^^) mais tout est une question de performances et de genericité.

Le but etait ici de fournir une classe "utilitaire d association" reposant c vrai assez fortement sur la classe Array et proposant de multiples fonctions pouvant etre interessantes dans differents cas avec des performances restant "constantes" quelle que soit la taille de la map.

et surtout le fait est que je suis developpeur Java et que je trouve cette classe tres pratique et tres performante et j ai été decu de ne pas la retrouver dans flash donc je l ai ecrite et donc pourquoi la faire decouvrir a tout le monde :p.

Commentaire de attonnnn le 14/11/2006 23:31:42

ah car tu ne l avais pas regarder.....
en effet je viens de voir qu'il a aussi implémenter une hashmap utilisant Dictionary, une nouvelle classe AS3. Je suis plus "old school" as2 avec des tableaux ^^.
pour ceux s interessant aux maps :
http://www.tweenpix.net/blog/index.php?2006/03/21/545-une-map-native-en-as3