Remplir un hashset avec des clefs

En fait c'est une Pair<Clef, Element> donc générique à l'implémentation et on définit les deux types dans le main.

non j'utilise un vecteur !


Et D'ailleurs mon constructeur par clonage ne fonctionne pas non plus et je ne sais pas comment faire ^^ si tu as une idée c'est cool aussi ! :)


Voici tout mon code comme ça tu comprendra le déroulement des choses :

import java.util.*;

public class TableHash<Clef,Element> implements Table<Clef,Element> {

private class Pair<Clef,Element>{
  public Clef key;
  public Element element;

Pair(Clef key, Element element){
   this.key=key;
   this.element=element;
  }//Pair
  public String toString(){
   return "("+key+","+element+")";
  }//toString
 }//Pair

Vector<LinkedList<Pair<Clef,Element>>> tab;
 int count;

public TableHash(){
  tab=new Vector<LinkedList<Pair<Clef,Element>>>();
  tab.add(new LinkedList<Pair<Clef,Element>>());
  count=0;
 }//TableHash


public TableHash(int length){
  tab=new Vector<LinkedList<Pair<Clef,Element>>>();
  for(int i=0; i<length; i++){
   tab.add(new LinkedList<Pair<Clef,Element>>());
  }//for i
  count=0;
 }//TableHash


public TableHash(Table<Clef,Element> t){
  tab=new Vector<LinkedList<Pair<Clef,Element>>>();
  count=0;
  this.putAll(t);
 }

public int size(){
  return tab.size();
 }//size

public int getCount(){
  return count;
 }//getCount

public double getLoadFactor(){
  return ((double)count/tab.size());
 }//getLoadFactor

protected final int f(Object object){
  return object.hashCode();
 }//f

protected final int g(int x){
  return Math.abs(x)%size();
 }//g

protected final int h(Object object){
  return g(f(object));
 }//h

public void put(Clef key, Element element){
  if(!(containsKey(key))){
   tab.get(h(key)).add(new Pair<Clef,Element>(key,element));
   count++;
  }else{
   System.out.println("Erreur :: Clef deja presente !");
  }
 }//put

public Element get(Clef key){
  LinkedList<Pair<Clef,Element>> l=tab.get(h(key));
  for(int i=0; i<l.size(); i++){
   if((l.get(i).key).equals(key)){
    return l.get(i).element;
   }
  }
  return null;
 }//get

public boolean containsKey(Clef key){
  int i=0;
  boolean test=false;
  LinkedList<Pair<Clef,Element>> l = tab.get(h(key));
  while(i<l.size() && !test){
   if((l.get(i).key).equals(key)){
    test=true;
   }//if
   i++;
  }//while
  return test;
 }

public Element remove(Clef key){
  LinkedList<Pair<Clef,Element>> l=tab.get(h(key));
  for(int i=0; i<l.size(); i++){
   if((l.get(i).key).equals(key)){
    count--;
    return (l.remove(i).element);
   }
  }
  return null;
 }//remove


public boolean containsValue(Element element){
  boolean test = false;
  for(int i=0; i<size(); i++){
   LinkedList<Pair<Clef,Element>> l=tab.get(i);
   for(int j=0; j<l.size(); j++){
    if((l.get(j).element).equals(element)){
     test=true;
    }
   }//for j
  }//for i
  return test;
 }


public boolean isEmpty(){
  return (count<=0);
 }


public void clear(){
  for(int i=0; i<size(); i++){
   LinkedList<Pair<Clef,Element>> l=tab.get(i);
   for(int j=0; j<l.size(); j++){
     l.clear();
   }//for j
  }//for i
 }


public Set<Clef> keySet(){
  //Stock toutes les clefs dans un ensemble hashSet et retourne cet ensemble
   HashSet<Clef> set = new HashSet<Clef>();
   for(int i=0; i<size(); i++){
    LinkedList<Pair<Clef,Element>> l = tab.get(i);
    for(int j=0; j<l.size(); j++){
     set.add(l.get(j).key);
    }
   }
     return set;
 }

//     set.add(l.get(j).key);




public String toString(){
  String ch="[";
  LinkedList<Pair<Clef,Element>> l;
  for(int i=0; i<size(); i++){
   l=tab.get(i);
   for(int j=0; j<l.size(); j++){
    ch+=l.get(j) + ";";
   }//for j
   //ch+=" ; ";
  }//for i

ch+="]";
  return ch;
 }

public static void main(String[] args) {

//Constructeur avec paramètre
  TableHash<Integer, String> t0 = new TableHash<Integer, String>(12);
  System.out.println("Table t0 : " + t0);

//Constructeur par défaut
  System.out.println();
  TableHash<Integer, String> t1 = new TableHash<Integer, String>();
  System.out.println("Table t1 : " + t1);

t1.put(4,"Avril");
  t1.put(5, "Mai");
  t1.put(6,"Juin");
  System.out.println("Table t1 : " + t1);

//Constructeur par copie
  System.out.println();
  TableHash<Integer, String> t2 = new TableHash<Integer, String>(t1);
  System.out.println("Table t2 : " + t2);


System.out.println();
  System.out.println("taille de t0 : "+t0.size());
  System.out.println("Valeur stocké dant t0 : "+t0.getCount());
  System.out.println("getLoadFactor de t0 : "+t0.getLoadFactor());
  System.out.println("t0 Vide ? : "+ t0.isEmpty());
  t0.put(1,"Janvier");
  t0.put(2, "Fevrier");
  t0.put(3,"Mars");

System.out.println("Table t0 : " + t0);
  t0.remove(1);
  System.out.println("Table t0 : " + t0);
  System.out.println("Valeur stocké dant t0 : "+t0.getCount());

System.out.println("Contient la valeur Fevrier dans t0 : " + t0.containsValue("Fevrier"));
  System.out.println("t0 Vide ? : "+ t0.isEmpty());
  t0.clear();
  System.out.println("Table t0 : " + t0);
  System.out.println("HashSet de t0 : " +t0.keySet());


}

@Override
 public void putAll(Table<Clef, Element> m) {
  // TODO Auto-generated method stub

}

}

Merci pour ton temps c'est cool !


Je viens de voir que je n'avais pas implémenter la méthode putall ... D'où le fait que mon constructeur par clonage ne fonctionne pas... Mais sachant que ça revient au-même que pour le constructeur, je ne sais pas trop comment faire !

Vector ne devrait plus être utilisé, il devrait être remplacé par ArrayList.

De plus, c'est bizarre d'avoir des LinkedList dedans, normalement une Map n'a qu'une dimension et en cas de collision on recalcule un hashCode secondaire... normalement ça ne vient pas s'ajouter dans une liste.

Et pour revenir à la question de comment faire le HashSet des clés, il me semble que la manière dont tu as fait fonctionne... même si on peut la simplifier un peu avec des boucles foreach :

public Set<Clef> keySet() {
    Set<Clef> set = new HashSet<Clef>();
    for (List<Pair<Clef, Element>> list : tab)
        for (Pair<Clef, Element> pair : list)
            set.add(pair.key);
    return set;
}

Si je te dis que l'ensemble clefs d'une table vide est vide...

En fait, je pensais qu'elle ne marchait pas car elle m'affichait toujours un ensemble vide mais...

Juste avant j'ai vidé ma table t0... !

Bref... Je suis un boulet mdr désolé ! mais c'est en prenant la tienne qui était sensé marchait que je me suis douté de qqch en voyant le même résultat !

En tout cas merci beaucoup !

Par contre... C'est quoi le principe des foreach ? Ca m'a l'air assez intéressant !

Et pour répondre à tes questions du vector etc.. C'est mon prof qui nous a imposé ça et cette façon de faire ! du coup tu as surement raison mais il voulait nous le faire faire comme ça !

Les boucles foreach sont une manière plus simple d'écrire des boucles qui parcourent l'intégralité des valeurs sans avoir besoin de l'index auxquelles elles se trouvent.

1) Avec un tableau, par exemple de type

E[] array

:

for (E element : array) {
    // ...
}

est équivalent à :

for (int i=0; i<array.length; i++) {
    E element = array[i];
    // ...
}

2) Avec un objet

Iterable<E> iterable

:

for (E element : iterable) {
    // ...
}

est équivalent à :

for (Iterator<E> it = iterable.iterator(); it.hasNext();) {
    E element = it.next();
    // ...
}

Remarque : Iterable est une interface implémentée notamment par les collections (Vector, List , Set etc.). Donc un des gros avantage c'est d'avoir une syntaxe commune pour itérer sur tous ces objets de type différents et donc de pouvoir changer de type sans avoir à réécrire les boucles for qui les manipulent.