Discussion :

[kylan]

bonjour!
comment rechercher un chaine de caractère dans un arraylist.
j'ai une chaine de caractère (A,B,C,G,H,J,K,U) que j'aimerai parcourir et comparer les caractères avec BDE .
et si BDE n'est pas présent je retourne vrai.

mon problème se trouve au niveau de la comparaison de mes caractères.je pensais utiliser contains mais je ne sais pas comment m'y prendre
merci

Code :

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

1
2
3
4
5
6
 
for(int i=0; i<this.size(); i++) 
 {
  ????
} 
return false;

[joel.drigo]

Salut,

et si BDE n'est pas présent je retourne vrai.

Ce ne serait pas plutôt faux si BDE n'est pas présent ? Ce serait plus logique...

Enfin, peu importe. Tu as deux façons de résoudre ton problème. Par parcourt, comme tu le suggères : il te suffit d'avoir un index pour parcourir la liste principale, metton indexPrincipal, et un autre pour la liste cherchée, mettons indexCherche. Avec la méthode List.get(index) tu peux récupérer les valeurs dans les listes et les comparer ensemble (simple equals()). Le principe étant (la liste cherchée doit contenir au moins un élément) :

Code pseudocode :

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
 
tant que indexPrincipal < taille de liste principale
       tant que indexCherche < taille de liste cherchée et
                   indexPrincipal + indexCherche < taille de liste principale et
                   chaine située à indexPrincipal+indexCherche dans liste principale est égale à chaine située à indexCherche dans liste cherchée // en gros, tant que les 2 éléments sont égaux on va avancer dans la liste cherchée et dans la liste principale en même temps
            indexCherche <- indexCherche + 1 // on compare l'élément suivant
       fin tant que
       si indexCherche == taille de liste cherchée alors // on a parcourut toute la chaine cherchée, donc on l'a trouvée
          "chaine" trouvée !
          // on peut arrêter la recherche...
       sinon
          réinitialiser indexCherche pour recommencer la recherche dans la suite de la boucle         
       fin si
       indexPrincipal <- indexPrincipal + 1 // on cherche plus loin
fin tant que   
si on arrive ici sans trouver la "chaine" alors elle n'est pas présente

Une autre solution consiste à utiliser la méthode List.indexOf(item, index) : elle te permet de chercher la position d'un élément dans la liste, à partir d'un index. Tu cherches ainsi un élément de la liste cherchée dans la liste principale, et si tu en trouves, tu fais la comparaison comme dans le cas précédent (la seconde boucle), et si la comparaison échoue, tu cherches la position suivante, etc.

[kylan]

Code :

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

1
2
3
4
tant que indexPrincipal < taille de liste principale
       tant que indexCherche < taille de liste cherchée et
                   indexPrincipal + indexCherche < taille de liste principale et
                   chaine située à indexPrincipal+indexCherche dans liste principale est égale à chaine située à indexCherche dans liste cherchée

je n'ai pas compris cette partie .pourquoi deux index pour la rechercher ?

[joel.drigo]

Soit ta première liste L1 : A - B - D - X - B - D - E - Z
Et ta seconde L2 : B - D - E.

1. On va parcourir L1, donc on va commencer par A, puis on parcourt L2, on prend B : on teste A égal B : non, on continue le parcourt de L1
2. On prend le suivant dans L1, donc B, on prend le premier dans L2, donc B, on teste B égal B, oui, on continue le parcourt de L2
   
   1. On prend le suivant dans L1 (donc D) et dans L2(donc D), on teste D égal D, oui, on continue le parcourt de L2
   2. On prend le suivant dans L1 (donc X) et dans L2(donc E), on teste X égal E, non, on arrête le parcourt de L2, et on continue le parcourt de L1
3. on prend le suivant dans L1, donc D, on prend le premier dans L2, donc B, on teste D = B, non, on continue le parcourt de L1
4. on prend le suivant dans L1, donc X, on prend le premier dans L2, donc B, on teste X = B, non, on continue le parcourt de L1
5. On prend le suivant dans L1, donc B, on prend le premier dans L2, donc B, on teste B égal B, oui, on continue le parcourt de L2
   
   1. On prend le suivant dans L1 (donc D) et dans L2(donc D), on teste D égal D, oui, on continue le parcourt de L2
   2. On prend le suivant dans L1 (donc E) et dans L2(donc E), on teste E égal E, oui, on continue
   3. On a atteint la fin de la chaine dans L2 : youpi, on a trouvé L2 dans L1 !!!

On voit bien qu'on parcourt L1 et L2, donc deux index, un pour parcourir L1, et un pour parcourir L2 (qui sert aussi à parcourir L1, mais à partir de l'index qui sert à parcourir L1 (d'où le indexPrincipal + indexCherche)).

Il y a un autre moyen qui permet de se passer de second index, en passant par une méthode de List (qui rend l'algo moins "dans le sens de l'exercice" je pense) :

Code :

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

list1.sublist( début, fin ).equals( list2 )

avec début l'index de parcourt de list1 (ou obtenu avec indexOf() (qui est également d'ailleurs moins dans le sens de l'exercice)), et le plus petit nombre entre l'index+la taille de list2, et la taille de list1...

[kylan]

super merci!