recherche dans un String[]

Version imprimable

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:

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);

18/04/2018, 14h13
joel.drigo

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"]...

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

Code:

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:

[]

18/04/2018, 14h37
joel.drigo

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

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.

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

Code:

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:

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

Le programme que tu fais, c'est :

pour chaque nombre dans motifs, appelé motif

pour chaque nombre dans valeurs, appelé valeur

si on est sur une position dans valeurs de timestamp alors

si le motif est dans la liste des valeurs d'un timestamp alors

on ajoute le timestamp
fin si
on vide liste des valeurs d'un timestamp
sinon

on ajoute valeur dans une liste appelée liste des valeurs d'un timestamp
fin si
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:

Set<String> list = new LinkedHashSet<>();

Le reste du code ne change pas.
Et pour convertir en List à la fin :

Code:

List<String> zelist = new ArrayList<>(list);
Ou alors il faut ajouter le timestamp uniquement s'il ne s'y trouve pas :
Code:

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:

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 } }