Passage de List à Map

**stardeus** · 19/11/2006, 16h52

Bonjour

A partir d'une liste contenant plusieurs éléments de type Arraylist , je souhaiterais calculer les occurences de cette liste par l'intermediaire d'un
Map.
Le probleme c'est que je ne vois pas comment m'y prendre. Pourriez vous me donner quelques pistes merci.

Voici le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
 
public  class Liste 
{   
    private  List<String> v;
    private  Map<String,Integer> map; 
 
    public Liste(){
     v = new ArrayList<String>(); 
 
    }
 
    public void affiche()
    {   
        System.out.println("liste de A:"+ v);  
    }  
    public boolean add(String t)
    {   
        boolean modified = false;
        modified = v.add(t);            
        return modified;
    }
 
    public Map<String,Integer> OccurrencesDesMots(List<String> list)
    { 
      /** je pense que je devrais passer la liste en parametre 
         *  l'ensemble map va ajouter la liste v 
         *  probablement je devrais faire un contains pour savoir si la chaine  est  contenu plusieurs fois dans la liste 
         */
 
      map = new HashMap<String,Integer>();  
 
 
      return map;
    }
 
 
    }

**stardeus** · 19/11/2006, 22h27

Bonsoir

J'ai un peu avancé. Pour établir les occurences de cette liste par l'intermediaire d'un Map contenant <string, integer>
( string correspond au mot et integer correspond le nombre d'occurence).
Donc j'ai bien utilisé un iterateur pour le parcours de la liste.J'ai extrait un ensemble de type String s.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
Map<String,Integer> table = new HashMap<String,Integer>(); 
      Iterator it = liste.iterator(); 
      while(it.hasNext()){
            for(int i=0;i<liste.size();i++){
               String s = (String) it.next();
            /**
               *              
               *
               */
 
               table.put(s,nbocc);
               System.out.println("clé:"+ table.keySet() +"valeur"+ table.values()); 
               }
           }
 
      return table;

Pour gerer le nb occurrence est ce que je pourrais resoudre le probleme en utilsant un deuxieme iterateur it2 à partir de l'ensemble de type String qui vient d' etre extraire . iterator i2 = liste.iterator() .J'extrais un nouvel element de type String s2.

Ensuite je compare s1.equals(s2) . si ceci est vrai alors je cree un compteur pour ajouter le nombre d'occurence

Pourriez vous dire si le raisonnement est correct. et est ce que je peux utiliser la methode equals. car je ne suis pas certain de pouvoir utilser cette equals ou encore contains.

merci d'avance

**stardeus** · 20/11/2006, 00h11

Bonsoir

je vous envoie ce que j'ai codé. Et la methode occurrencedesmots ne semble pas fonctionner pourriez vous me dire ce qui ne vas pas

merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
public class Chapitre2CoreJava2{
 
 
    public static List<String> listeDesMots()
    {
       List<String> liste; 
       liste = new ArrayList<String>(); 
       String s = "toto pospos ; totot, totot, tata  tata  "; 
       StringTokenizer st = new StringTokenizer(s,"[](){};, :.\n\"");    
       System.out.println("Nombre de mots" + st.countTokens());
       while (st.hasMoreTokens()) 
          {/** Tant qu'il existe encore des éléments */
               System.out.println(st.nextToken());
          }
          return liste;
    }
 
    public static Map<String,Integer> OccurrencesDesMots(){
      List <String> liste = listeDesMots();
      int cpt = 0; /**création d'un compteur*/
      Map<String,Integer> table = new HashMap<String,Integer>();    /**associe une clef à une valeur et de retrouver une clef à partir d'une valeur*/
      Iterator it = liste.iterator(); /** créateur d'un itérateur pour parcourir la liste */
      while(it.hasNext())/** tant que le liste tjs un element on se place a l'element suivant*/
           {               
               for(int i=0;i<liste.size();i++) 
               {
                   String s = (String) it.next();
                   System.out.println(s);
                   Iterator it2 = liste.iterator();
                   while(it2.hasNext())
                        {
                           for(int j=0;j<liste.size();j++)
                           {
                              String s2 = (String) it2.next(); 
                              if (s.equals(s2))
                               { 
                                 cpt += 1;
                                 System.out.println("compteur"+cpt);  
                                }
                            }    
                         }                  
                    table.put(s,cpt);
                    System.out.println("clé:"+ table.keySet() +"valeur"+ table.values());  
                 }
             }
 
 
      return table;
    }

**JMLLB** · 20/11/2006, 05h54

Je ne suis pas spécialiste des templates mais j'ai 2 remarques:
-Où se fait l'affectation de valeur à ta variable liste de retour de la fonction listeDesMots()?
-2 variables qui travaillent sur le même itérateur ça me semble chaud! Je pense que si tu veux être sûr de tes déplacements via un itérateur, il faut avoir 2 objets bien distincts.

**stardeus** · 20/11/2006, 11h06

Bonjour,

Où se fait l'affectation de valeur à ta variable liste de retour de la fonction listeDesMots()?

L'affectation a eu lieu utilisant cette variable dans la methode Map<String,Integer> OccurrencesDesMots(){

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
List <String> liste = listeDesMots();

2 variables qui travaillent sur le même itérateur ça me semble chaud! Je pense que si tu veux être sûr de tes déplacements via un itérateur, il faut avoir 2 objets bien distincts.

J'ai crée 2 iterateur (it et it2) afin d'en extraire deux objets . Ensuite l'objet verifie l'egalité entre l'objet s2 (qui a été extraite suite à la 2e itération).

**JMLLB** · 20/11/2006, 12h24

L'affectation a eu lieu utilisant cette variable dans la methode Map<String,Integer> OccurrencesDesMots()

Je suis d'accord, mais il ne me semble pas que dans la méthode listeDesMots la variable liste déclarée en 1, créée en 2 et retournée en 3 soit affectée à une valeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
    public static List<String> listeDesMots()
    {
       List<String> liste; // <= 1
       liste = new ArrayList<String>(); // <= 2
       String s = "toto pospos ; totot, totot, tata  tata  "; 
       StringTokenizer st = new StringTokenizer(s,"[](){};, :.\n\"");    
       System.out.println("Nombre de mots" + st.countTokens());
       while (st.hasMoreTokens()) 
          {/** Tant qu'il existe encore des éléments */
               System.out.println(st.nextToken());
          }
          return liste; // <= 3
    }

Pour le deuxième point, je peux me tromper, mais il me semble que la méthode iterator ne fournit qu'une référence sur un itérateur et n'effectue pas de création.
Si c'est effectivement le cas it et it2 "pointent" sur le même objet.
Un coup d'oeil avec le débugger et tu en auras le coeur net.

**stardeus** · 20/11/2006, 14h38

Bonjour,

Je suis d'accord, mais il ne me semble pas que dans la méthode listeDesMots la variable liste déclarée en 1, créée en 2 et retournée en 3 soit affectée à une valeur.

Effectivement la liste ne retourne pas de valeur. Pour ce faire, on a ajoute les elements extraites a la liste.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 public static List<String> listeDesMots()
    {
       List<String> liste; // <= 1
       liste = new ArrayList<String>(); // <= 2
       String s = "toto pospos ; totot, totot, tata  tata  "; 
       StringTokenizer st = new StringTokenizer(s,"[](){};, :.\n\"");    
       System.out.println("Nombre de mots" + st.countTokens());
       while (st.hasMoreTokens()) 
          {/** Tant qu'il existe encore des éléments */
                String extraire = (String) st.nextToken());
                liste.add(extraire);            
          }
          System.out.println(liste);
          return liste; // <= 3
    }

il me semble que la méthode iterator ne fournit qu'une référence sur un itérateur et n'effectue pas de création

Je suis d'accord avec toi , la maniere dont je pensais gerer les occurences de la liste de mots n'est pas la bonne.
Je ne vois pas comment je pourrais m'y prendre. Avez vous une piste comment faire.

Je rappelle que la map devrait avoir comme clé le mot suivi de sa valeur correspondant au nombre d'occurence.
Je suppose que je devrais créer un compteur.

**JMLLB** · 20/11/2006, 15h06

Tu devrais pouvoir t'en sortir juste avec table et it .

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static Map<String,Integer> OccurrencesDesMots(){
      List <String> liste = listeDesMots();
      Map<String,Integer> table = new HashMap<String,Integer>();
      Iterator it = liste.iterator();
 
      while(it.hasNext())
           {
              Object tmpObject = it.next();
              if(table.ContainsKey(tmpObject))){
                int nbOcc=table.tmpObject.getValue();
                table.tmpObject.setValue(nbOcc+1);
                //Je ne connais pas la syntaxe des methode avec entrée getValue et setValue
              }
              else{ table.put(tmpObject,1);}
           }  
      return table;
    }

**stardeus** · 20/11/2006, 15h47

Bonjour

Je te remercie le code fonctionne maintenant.
Voici le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
  public static Map<String,Integer> OccurrencesDesMots(){
      List <String> liste = listeDesMots(); 
      Map<String,Integer> table = new HashMap<String,Integer>();
      Iterator it = liste.iterator(); /** créateur d'un itérateur pour parcourir la liste */
      while(it.hasNext())/** tant que la liste a tjs un element on se place a l'element suivant*/
           {               
                   String mot = (String) it.next();
                   if(table.containsKey(mot)) 
                     {
                       table.put(mot, Integer.valueOf((Integer)table.get(mot) + 1));                      
                     }else{                            
                            table.put(mot, Integer.valueOf(1));
                          }                        
          }       
          System.out.println(table); 
          return table;

**®om** · 20/11/2006, 16h08

En utilisant correctement les generics (en mettant Iterator<String>), tu n'as pas besoin du tout de cast...

Par exemple (et en enlevant les trucs inutiles, avec l'auto(un)boxing) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

table.put(mot, Integer.valueOf((Integer)table.get(mot) + 1));

==>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

table.put(mot, table.get(mot) + 1);

**stardeus** · 20/11/2006, 16h42

Bonjour

C'est vrai c'est beaucoup mieux

Voila ce que ça donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
    public static Map<String,Integer> OccurrencesDesMots(){
      List <String> liste = listeDesMots(); 
      Map<String,Integer> table = new HashMap<String,Integer>();
      Iterator<String> it = liste.iterator(); /** créateur d'un itérateur pour parcourir la liste */
      while(it.hasNext())/** tant que la liste a tjs un element on se place a l'element suivant*/
           {               
                   String mot =it.next();
                   if(table.containsKey(mot)) 
                     {
                       table.put(mot,table.get(mot)+ 1);                      
                     }else{                            
                            table.put(mot,1);
                          }                        
          }       
          System.out.println(table); 
          return table;

Je te remercie.

**®om** · 20/11/2006, 18h45

Allez, encore "mieux":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    public static Map<String,Integer> occurrencesDesMots(){
        Map<String,Integer> table = new HashMap<String,Integer>();
        for(String mot : listeDesMots()) {
            if(table.containsKey(mot))
                table.put(mot, table.get(mot) + 1);
            else
                table.put(mot, 1);
        }
        return table;
    }

ou encore, sans doute plus rapide:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
    public static Map<String,Integer> occurrencesDesMots(){
        Map<String,Integer> table = new HashMap<String,Integer>();
        for(String mot : listeDesMots()) {
            Integer i = table.get(mot);
            if(i == null)
                table.put(mot, 1);
            else
                table.put(mot, i+1);
        }
        return table;
    }

**stardeus** · 21/11/2006, 03h47

Bonjour ,

J'ai testé les 2 methodes que tu as proposé.Malgré que tu as mal placé ton return et un oubli d'une parenthese, ton code fonctionne correctement.

Je remarque que tu n'utilise pas d'iterateur pour parcourir la liste. alors comment extrais tu la variable?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
for(String mot : listeDesMots() )

Pourrais tu me traduire cette expression?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Integer i = table.get(mot);
            if(i == null) {  
                i = 0;

Pourrais tu m'expliquer cette partie de code?

On a une liste de ce type liste : ["toto", "tata", "toto", "titi"]
l'affichage de la map nous donne :["toto"=1, "tata"=0, "titi"=0]
je pense que le resultat obtenu est normal car le premier indice de la liste est à 0
Au lieu de travailler avec les String tu extrais des integer c'est bien ça ???

**®om** · 21/11/2006, 07h13

Envoyé par stardeus

Je remarque que tu n'utilise pas d'iterateur pour parcourir la liste. alors comment extrais tu la variable?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
for(String mot : listeDesMots())

Pourrais tu me traduire cette expression?

Cette expression est équivalente (elle fait exactement la même chose) que:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Iterator<String> it = listeDesMots().iterator();
while(it.hasNext()) {
    String mot = it.next();
    ...
}

(voir : http://java.developpez.com/faq/java/...ORD_for_etendu)

Envoyé par stardeus

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Integer i = table.get(mot);
            if(i == null) {  
                i = 0;

Pourrais tu m'expliquer cette partie de code?

Un .get sur une Map renvoie null si l'élément n'existe pas (pas besoin de faire un containsKey, ça t'évite un calcul).
Donc on teste si l'entier est nul.
après, i = 0 est inutile car je n'utilise plus i, et en plus il faut mettre 1 (je viens de corriger). et ça utilise l'autoboxing.

Envoyé par stardeus

On a une liste de ce type liste : ["toto", "tata", "toto", "titi"]
l'affichage de la map nous donne :["toto"=1, "tata"=0, "titi"=0]
je pense que le resultat obtenu est normal car le premier indice de la liste est à 0

Avec la correction, maintenant c'est à 1

Envoyé par stardeus

Au lieu de travailler avec les String tu extrais des integer c'est bien ça ???

Non, la clé c'est String, la valeur c'est Integer... comme ce que tu faisais...