recherche dans un String[]

**student student** · 18/04/2018, 13h15

Salut, j'ai des valeurs stockées dans un String[], et j'ai des autres motif que je veux les chercher dans ces valeurs, dans cette exemple j'ai String[] valeurs qui est la base qui contient les valeurs, et motif1 contient "102 103 104 205", je dois parcourir la base et à chaque fois que je trouve ces 4 valeurs ensemble je retourne leur temps qui la 11ème colonne, le résultat est correct lorsque je cherche un seul nombre mais quand plusieurs nombres qui doivent apparaître ensemble ça marche pas, c'est le code que j'ai essayé mais il me donne un résultat vide à la fin

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
Set<String> valeursAvantTimeStamp = new HashSet<>();
				   List<String> list = new ArrayList<>();
		 String[] valeurs = "201,202,103,104,205,206,107,208,209,110, 1216471380, 201,102,203,204,205,206,107,108,109,110, 1216473720, 201,202,103,104,205,206,107,108,109,210, 1216482780, 201,102,103,104,205,206,207,108,109,210	1216489440, 201,202,103,104,205,206,207,108,109,210, 1216489500, 201,202,103,104,205,206,107,108,109,110, 1216491840, 201,202,103,104,205,206,207,108,109,210, 1216496100, 201,202,103,104,205,206,207,108,109,210, 1216497420".split(",");
		 String[] motif1= "102 103 104 205".split(" ");
		 String[] motif2= "103".split("");
 
		 for(int i=0; i<motif1.length; i++) {
			 for(int j=0; j<valeurs.length; j++) {
				 if ( (j+1)%11==0 ) {
			 // la valeur est un timestamp
					 if ( valeursAvantTimeStamp.contains(motif1[i]) ) 
					 {
						 i++; 
						list.add(valeurs[i]);
 
					 }
 
 
		 valeursAvantTimeStamp.clear(); // on vide le set pour continuer
 
 
				 }else {
		 // la valeur n'est pas un timestamp
		 valeursAvantTimeStamp .add(valeurs[i]); // on stocke la valeur
		 }
 
		 }
		 }	 
		System.out.println(list);

**joel.drigo** · 18/04/2018, 14h13

Tu parcours le tableau motif1 avec i et le tableau de valeurs avec j. Sauf que tu accèdes aux valeurs dans le tableau valeurs par l'indice i, donc tu n'ajoutes jamais d'autres valeurs de valeurs que les 4 premières du tableau, et aucun valeurs[a] n'est égale à un motif1[a] pour 0<=a<4, donc le contains est toujours faux. Et tu as de la chance que motif1 soit plus petit que valeurs sinon il y aurait une exception.

Par ailleurs, String[] motif2 = "103".split("");, ça donne ["1", "0", "3"]...

**student student** · 18/04/2018, 14h30

j'ai modifier le motif1 en tableau d'entiers et j'ai corrigé les indices:

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
Set<String> valeursAvantTimeStamp = new HashSet<>();
				   List<String> list = new ArrayList<>();
		 String[] valeurs = "201,202,103,104,205,206,107,208,209,110, 1216471380, 201,102,203,204,205,206,107,108,109,110, 1216473720, 201,202,103,104,205,206,107,108,109,210, 1216482780, 201,102,103,104,205,206,207,108,109,210	1216489440, 201,202,103,104,205,206,207,108,109,210, 1216489500, 201,202,103,104,205,206,107,108,109,110, 1216491840, 201,202,103,104,205,206,207,108,109,210, 1216496100, 201,202,103,104,205,206,207,108,109,210, 1216497420".split(",");
		 int [] motif1= {102,103,104,205};
		 String[] motif2= "103".split(" ");
 
		 for(int i=0; i<motif1.length; i++) {
			 for(int j=0; j<valeurs.length; j++) {
				 if ( (j+1)%11==0 ) {
			 // la valeur est un timestamp
					 if ( valeursAvantTimeStamp.contains(motif1[i]) ) 
					 {
						 i++; 
						list.add(valeurs[j]);
 
					 }
 
 
		 valeursAvantTimeStamp.clear(); // on vide le set pour continuer
 
 
				 }else {
		 // la valeur n'est pas un timestamp
		 valeursAvantTimeStamp .add(valeurs[j]); // on stocke la valeur
		 }
 
		 }
		 }	 
		System.out.println(list);

et le résultat est

Code :

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

[]

**joel.drigo** · 18/04/2018, 14h37

J'ai jamais dit de passer "motifs" en int[] !?

Un int n'étant jamais égal à un String, valeursAvantTimeStamp.contains(motif1[i]) ne sera jamais vrai ! Remet motif1 comme il était.

En revanche, ce qu'il faudra que tu fasses quelque chose pour i++. Soit tu parcours le tableau par la boucle for, en incrémentant i à chaque boucle, soit tu incrémentes i dans le bloc "if contains", mais les deux, ça risque de foutre la zone des que le contains va être vrai (puisqu'à chaque fois que le if/contains est vrai, on incrémente 2 fois i dans la même itération, d'où risque de dépassement de longueur de tableau selon les valeurs dans les tableaux.

**student student** · 18/04/2018, 15h23

il y avait une erreur dans le remplissage de valeurs, en fait maintenant ça affiche un résultat

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
Set<String> valeursAvantTimeStamp = new HashSet<>();
				   List<String> list = new ArrayList<>();
		 String[] valeurs = "201,102,103,104,205,206,107,108,109,110, 1216461300, 201,102,103,104,205,206,107,108,109,110, 1216463520, 201,202,103,104,205,206,207,108,109,210, 1216466220".split(",");
		 String[] motif1= "102 103 104 205".split(" ");
 
 
		 for(String x : motif1) {
			 for(int j=0; j<valeurs.length; j++) {
				 if ( (j+1)%11==0 ) {
			 // la valeur est un timestamp
					 if ( valeursAvantTimeStamp.contains(x)) 
					 {
 
						 list.add(valeurs[j]);
 
					 }
 
 
		 valeursAvantTimeStamp.clear(); // on vide le set pour continuer
 
 
				 }else {
		 // la valeur n'est pas un timestamp
		 valeursAvantTimeStamp .add(valeurs[j]); // on stocke la valeur
		 }
 
 
		 }	 
		System.out.println(list);

le résultat est

Code :

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

1
2
3
4
[ 1216461300,  1216463520]
[ 1216461300,  1216463520,  1216461300,  1216463520,  1216466220]
[ 1216461300,  1216463520,  1216461300,  1216463520,  1216466220,  1216461300,  1216463520,  1216466220]
[ 1216461300,  1216463520,  1216461300,  1216463520,  1216466220,  1216461300,  1216463520,  1216466220,  1216461300,  1216463520,  1216466220]

mais normalement il doit être seulement [ 1216461300, 1216463520], puisque 102 103 104 205 apparaissent ensemble dans les 1er et les 2ème 10 valeurs, apparemment il y a une boucle mal gérée

**joel.drigo** · 18/04/2018, 15h37

Le programme que tu fais, c'est :

pour chaque nombre dans motifs, appelé motif
1. pour chaque nombre dans valeurs, appelé valeur
  1. si on est sur une position dans valeurs de timestamp alors
    1. si le motif est dans la liste des valeurs d'un timestamp alors
      1. on ajoute le timestamp
    2. fin si
    3. on vide liste des valeurs d'un timestamp
  2. sinon
    1. on ajoute valeur dans une liste appelée liste des valeurs d'un timestamp
  3. fin si
2. fin pour
fin pour

Comme 102, 103, 104 et 205 (quatre motifs) se trouvent dans "201,102,103,104,205,206,107,108,109,110", on retrouve quatre fois 1216461300, forcément (on ajoute le timestamp ne fait rien d'autre que d'ajouter le timestamp, même s'il se trouve déjà dans la liste.

C'est juste un problème de doublon.

On peut régler ça facilement en utilisant un Set au lieu d'une List, puisque la définition d'un Set fait qu'une valeur ne peut s'y trouver qu'une seule fois. En utiliant un LinkedHashSet on peut conserver l'ordre comme dans un List, et on peut toujours convertir à la fin en List au besoin...
Tu définis list comme ça
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
Set<String> list = new LinkedHashSet<>();
```
Le reste du code ne change pas.
Et pour convertir en List à la fin :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
List<String> zelist = new ArrayList<>(list);
```

Ou alors il faut ajouter le timestamp uniquement s'il ne s'y trouve pas :

Code :

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

1
2
3
4
5
if ( valeursAvantTimeStamp.contains(x)) {
 
   if ( !list.contains(valeurs[j]) ) list.add(valeurs[j]);
 
}

PS note que je viens juste de voir le "ensemble" dans ton post, et que ce n'est effectivement pas ce que fait ton code (il vérifie chaque motif séparément).

[edit]pour vérifier la présence conjointe de tous les "motifs" :

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
 
String[] valeurs = /*...*/
		List<String> motif1 = Arrays.asList("102 103 104 205".split(" "));
		 	for (int j = 0; j < valeurs.length; j++) {
				if ((j + 1) % 11 == 0) { 
					// la valeur est un timestamp
					if ( valeursAvantTimeStamp.containsAll(motif1) ) { // teste si tous les éléments de motif1s sont dans valeursAvantTimeStamp
						list.add(valeurs[j]);
					}
					valeursAvantTimeStamp.clear(); // on vide le set pour continuer
 
				} else {
					// la valeur n'est pas un timestamp
					valeursAvantTimeStamp.add(valeurs[j]); // on stocke la valeur
				}
 
			}

recherche dans un String[]

avec Java

Vue hybride

Discussions similaires

Partager

Partager