Discussion :

[abbescr7]

Salut,

Je vais essayer d’être le plus clair

J'essaye de réaliser un analyseur lexical. J'ai un texte que j'ai découpé avec split et j'ai mis tous les mots dans un tableau. J'ai 5 listes : mots clé, séparateurs, identificateurs, opérateurs, constantes. Je voudrais, qu'à chaque fois qu'il trouve un mot, il le cherche dans les 5 listes et il me donne le mot avec le nom de la liste et son indice dans la liste.

Par exemple
public static ( ) public + 1111
mot clé (0) public
mot clé (1) static
séparateur (0) (
separateur (1) )
mot clé (0) public
opérateur (0) +
constante (0) 1111

Pour l'indice ça dépend de comment j'ai rempli ma liste

J'ai essayé avec ça

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
 
for(int i=0; i<tabmot.length;i++){
			System.out.println(tabmot[i]);
 
			if((a1.contains(tabmot[i])) ){
					System.out.println("mot clé " + i + " = " + a1.get(i));
			}	else if ((a2.contains(tabmot[i]))) 
						 System.out.println("separateurs " + i + " = " + a2.get(i));
			else			if ((a3.contains(tabmot[i])))
									System.out.println("operateur " + i + " = " + a3.get(i));
 
			else if ((a7.contains(tabmot[i])))
											System.out.println("identificateurs " + i + " = " + a5.get(i));
			else							if	 ((a5.contains(tabmot[i])))
 
											System.out.println("constantes " + i + " = " + a7.get(i));
 
 
 
 
 
			 }

[joel.drigo]

Salut,

Si list.contains(x) répond true si x se trouve dans list, ou false sinon, tu as aussi list.indexOf(x) qui retourne -1 si x n'est pas dans la liste, sinon la position de x dans la liste.

Par exemple :

Code :

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

1
2
3
4
f((a1.contains(tabmot[i])) ){
    System.out.println("mot clé " + tabmot[i] + ", position= " + a1.indexOf( tabmot[i]) )  );
}	else if ((a2.contains(tabmot[i]))) 
   /*...*/

Ou le faire seulement avec indexOf

Code :

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

1
2
3
4
5
int indexa1 = a1.indexOf(tabmot[i]);
if ( indexa1>=0 ) {
    System.out.println("mot clé " + tabmot[i] + ", position= " + indexa1 )  );
}	else { 
   /*...*/

Tu peux mettre tes listes dans une Map aussi, avec pour clef le nom

Code :

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

1
2
3
4
Map<String, List<String>> listes = new HashMap<>();
listes.put("mot clé", a1);
listes.put("sérateurs", a2);
/**...**/

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
public class ListePosition {
     private final String nom;
     private final int index;
     public ListePosition(String nom, int index) {
         this.nom=nom;
         this.index=index;
     }
     public String getNomListe() {
         return nom;
     }
     public int getIndexDansLaListe() {
         return index;
     }
     public static Optional<ListePosition> chercher(Map<String, List<String>> map, String mot) {
           return map.entrySet()
                     .stream()
                     .filter(e-> e.getValue().contains(mot))
                     .map(e-> new ListePosition(e.getKey(), e.getValue().indexOf(mot))
                     .findFirst();
     } 
}

Code :

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

1
2
3
4
5
6
7
Optional<ListePosition> position = ListePosition.chercher(listes, tabmot[i]);
if ( position.isPresent() ) {
    position.ifPresent(p-> System.out.printf("Mot %s  trouvé dans la liste %s en position %d%n", tabmot[i], p.getNomListe(), p.getIndexDansLaListe()+1)); 
}
else {
   System.out.println(tabmot[i]+ " : mot introuvable " );
}

[abbescr7]

merci beaucoup joel ça marche
par-contre j'ai voulu essayer avec le map
y a une erreur qui s'affiche

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
ArrayList a1 = new ArrayList();
    ArrayList a2 = new ArrayList();
    ArrayList a3 = new ArrayList();
    ArrayList a7 = new ArrayList();
    ArrayList a5 = new ArrayList();
    ArrayList a6 = new ArrayList();
 
	Map<String, List<String>> listes = new HashMap<>();
	listes.add("mot clé",a1);
	listes.add("sérateurs",a2);

the method add(String,Arraylist) is undifined for the type Map<String, List<String>>!!!
j'ai pas fais de bêtise j’espère ! ?

[joel.drigo]

the method add(String,Arraylist) is undifined for the type Map<String, List<String>>!!!
j'ai pas fais de bêtise j’espère ! ?

Oups ! Coquille de ma part : c'est put au lieu de add

[abbescr7]

y q toujours des erreur !
si ça te dérange pas tu peux m'aider je suis nouveau sur java
si je dis pas de bêtise
je dois ajouter une nouvelle classe ListePosition ou bien je met ce code dans la même classe ou y toute mes liste !!! y a beaucoup d'erreur Public ListePosition .....

[joel.drigo]

Oui tu dois faire une nouvelle classe ListePosition. En classe interne, il faudrait qu'elle soit public static, autant la faire à part.

Tu peux avoir des erreurs dans la méthode chercher() si tu es en Java 7 et pas Java 8, parce que j'utilise des notions qui n'existent que en Java 8 (les streams et les lambdas).

[abbescr7]

je suis en java 8
j'ai une erreur a la fin

Code :

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

1
2
 
 .findFirst();

il me dit que je dois ajouter ")" a la fin mais quand je l'ajoute toute la ligne deviens une erreur

Code :

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

1
2
3
 
.map(e-> new ListePosition(e.getKey(), e.getValue().indexOf(mot))
	                     .findFirst();)

[joel.drigo]

Code :

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

1
2
3
.map(e-> new ListePosition(e.getKey(), e.getValue().indexOf(mot)))
	                     .findFirst();)

oui, il manque une parenthèse (je l'ai mise en surlignée)

[abbescr7]

Code :

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

1
2
3
4
5
6
7
8
9
 
int i=0 ;	
		Optional<ListePosition> position = ListePosition.chercher(listes, tabmot[i]);
		if ( position.isPresent() ) {
		    position.ifPresent(e-> System.out.printf("Mot %s  trouvé dans la liste %s en position %d%n", tabmot[i], e.getNomListe(), e.getIndexDansLaListe()+1)); 
		}
		else {
		   System.out.println(tabmot[i]+ " : mot introuvable " );
		}

j'ai une erreur !!!!
Local variable tabmot defined in an enclosing scope must be final or effectively final

[joel.drigo]

Oui, effectivement, je n'y avais pas pensé : enfin, cette erreur est possible sur i, mais sur tabmot ce n'est pas normal, mais bon, il faudrait que je vois le reste du code, là où tu déclares tabmot[]. Mais on peut éviter ça (le problème avec i) en utilisant un foreach au lieu d'un for.

Code :

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

1
2
3
4
5
6
7
8
9
10
String[] tabmot = /*...*/ // une méthode probablement qui lit les mots dans un fichier.
for(String mot : tabmot ) {
     Optional<ListePosition> position = ListePosition.chercher(listes, mot);
     if ( position.isPresent() ) {
	position.ifPresent(e-> System.out.printf("Mot %s  trouvé dans la liste %s en position %d%n", mot, e.getNomListe(), e.getIndexDansLaListe()+1)); 
     }
     else {
	System.out.println(mot+ " : mot introuvable " );
     }
}

Ou encore, on peut répliquer le mot en attribut dans ListePosition (ça peut être mieux si on veut faire d'autres traitements ultérieures d'une liste des ListePosition trouvés, quoique qu'une map pourrait être également mieux adaptée à certains types de traitement).

[abbescr7]

Merci Beaucoup ça marche
juste si ça te dérange pas peut tu m'explique ce qu'on a fait juste pour comprendre
au moins devant le prof je vais pas lui dire copier coller

[joel.drigo]

Tu peux déjà consulter la javadoc des méthodes utilisées pour avoir des détails. Tu pouvais aussi utiliser la première méthode que j'ai indiquée avec les indexOf(), si tu te sens mieux pour l'expliquer (elle est très proche de ta méthode initiale, donc ça ne te devrait pas être très difficile). Surtout si c'est un exercice d'école (tu verras les notions utilisées plus tard dans ton cours sûrement).

Sinon, pour la solution avec map, une map associe des clefs et des valeurs : ici la clef c'est un nom (le nom de la liste), et la valeur la liste de mots associée.

Code :

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

1
2
3
4
5
6
7
public static Optional<ListePosition> chercher(Map<String, List<String>> map, String mot) {
           return map.entrySet() // on demande l'entry set de la map (l'ensemble des couples clef/valeur, donc nom de liste/liste de mots
                     .stream() // un stream est un objet Java permettant de traiter les données en flux (voir Javadoc et doc sur les streams du le site d'Oracle)
                     .filter(e-> e.getValue().contains(mot)) // on ne conserve que les entries dont la liste contient le mot
                     .map(e-> new ListePosition(e.getKey(), e.getValue().indexOf(mot)) // on transforme les entries conservées en ListePosition correspondant
                     .findFirst(); // on ne prend que le premier (mais normalement, si un mot n'appartien pas à plusieurs listes, on en a qu'un, donc le premier c'est le seul).
     }

Le principe des streams et que toutes les méthodes retournent le stream, d'où cette notation .method1().method2().method3().... à la fin, on ne veut plus du stream(), mais le résultat de ce qu'on a fait, donc ici on utilise findFirst() qui retourne le premier élément dans le stream.
Les méthodes utilisent en argument des trucs du genre : machin-> instruction. On appelle ça une expression lambda. c'est une simplification d'écriture qu'on peut utiliser pour remplacer une implémentation d'une interface dite fonctionnelle, c'est-à-dire qui n'a qu'une méthode à implémenter (soit qu'une seule méthode unique, soit que les autres sont préimplémentées du type default method).
Par exemple, la méthode filter() prend un argument de type Predicate<T> qui a une seule méthode, qui retourne un boolean correspondant au test d'une condition.
L'implémentation habituelle sans lambda expression est :

Code :

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

1
2
3
4
5
filter(new Predicate<Map.Entry<String, List<String>> { 
      public boolean test(Map.Entry<String, List<String> e) {
          return e.getValue().contains(mot);
      }
})

Tu peux voir que c'est nettement plus verbeux que filter(e-> e.getValue().contains(mot)). D'où l'intérêt d'une lambda-expression. Tu peux également voir le rapport qu'il y a entre les deux syntaxes

Code :

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

1
2
3
4
5
filter(new Predicate<Map.Entry<String, List<String>> { 
      public boolean test(Map.Entry<String, List<String> e) {
          return e.getValue().contains(mot);
      }
})

Code :

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

filter( e-> e.getValue().contains(mot) )

Code :

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

1
2
3
4
5
6
7
Optional<ListePosition> position = ListePosition.chercher(listes, mot); // on retourne un position, qui contient un résultat ou pas
		if ( position.isPresent() ) { // s'il y a un résultat
		    position.ifPresent(e-> System.out.printf("Mot %s  trouvé dans la liste %s en position %d%n", mot, e.getNomListe(), e.getIndexDansLaListe()+1)); // on affiche le résultat (pas besoin d'explication sur le printf ?)
		}
		else { // s'il n'y a pas de résultat
		   System.out.println(tabmot[i]+ " : mot introuvable " );
		}

La méthode findFirst() de Stream<T> retourne un Optional<T> : une classe qui va contenir ou pas la valeur de résultat qui nous intéresse. Elle est faite pour simplifier les écritures du type :

Code :

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

1
2
3
4
5
Machin object = getMachin();
if (object!=null ) {
   // faire quelque chose
   method(object);
}

qui vont s'écrire

Code :

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

1
2
3
4
5
Optional<Machin> optional = getMachin();
if (optional.isPresent() ) {
   // faire quelque chose
   method(optional.get());
}

ou avec une expression lambda :

Code :

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

1
2
Optional<Machin> optional = getMachin();
optional.ifPresent(object-> // faire quelque chose) // l'expression lambda correspond à l'implémentation de l'interface Consumer<t>

Un Optional<ListePosition> est donc un objet qui contient une instance de ListePosition, ou qui est vide.

[abbescr7]

Merci
je vais relire tous sa a tête reposer