Comment faire un split sur une list

Version imprimable

Bonjour, j'ai cette méthode
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 public static List<String> TimeStamp(String [] item, String[] ligne) { Set<String> valeursAvantTimeStamp = new HashSet<>(); List<String> list = new ArrayList<>(); for(int j=0; j<ligne.length; j++) { if ( (j+1)%11==0 ) { // la valeur est un timestamp for(String x : item) { if ( valeursAvantTimeStamp.contains(x)) { list.add(ligne[j]); } valeursAvantTimeStamp.clear();// on vide le set pour continuer } } else { // la valeur n'est pas un timestamp valeursAvantTimeStamp .add(ligne[j]); // on stocke la valeur } } return list; }
lorsque je la donne comme paramètres 207 pour item et cette ligne

Code:

[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]

elle me renvoie ce résultat

Code:

[ 1216489440, 1216489500, 1216496100, 1216497420]]

comment je peux éliminer l'accolade après 1216497420, il m'affiché deux accolades fermantes, je veux éliminer le premier pour pouvoir convertir les valeurs en entiers, avec cet affichage il me génère une exception
Code:

1 2 3 4 5 Exception in thread "main" java.lang.NumberFormatException: For input string: "1216497420]" at java.lang.NumberFormatException.forInputString(Unknown Source) at java.lang.Integer.parseInt(Unknown Source) at java.lang.Integer.parseInt(Unknown Source) at chronique.main(chronique.java:168)

24/04/2018, 20h24
joel.drigo
Salut,

il y a une confusion entre List, chaîne de caractères et chaîne de caractères représentant une List. Une chaîne de caractères est une chaîne de caractères, et tous les caractères qui s'y trouvent existent. Une List est une liste d'éléments. On peut l'afficher via sa représentation par chaîne de caractères, mais ce n'est qu'une représentation, pas la liste elle-même.

On peut construire une List à partir d'une chaîne de caractères avec la méthode split() qui découpe la chaîne suivant un motif de découpe et on obtient par là un tableau qu'on peut "convertir" (en réalité on ne convertit rien, on copie chaque élément du tableau dans une nouvelle instance de List, l'implémentation concrète dépendant de la façon de faire cette copie) en List. Il n'y a pas de méthode split() sur une List, parce que ce sont déjà des éléments séparés. On peut obtenir des sous parties de la liste (sublist) ou les éléments directement par get().
Code:

1 2 3 4 String[] decoupe = "1,2,3,4".split(","); List<String> list = Arrays.asList(decoupe); System.out.println(list);
affiche en console :
```
[1, 2, 3, 4]
```
.
ceci n'est pas la List, ce n'est qu'une représentation de celle-ci. On pourrait très bien avoir une autre représentation (avec un peu de code) et voir 1,2,3,4 ou 1->2->3->4 ou 1234...

Si en l'occurence tu fais après:
Code:

1 2 3 List<String> autrelist = new ArrayList<>(); autrelist.add( list.toString() ); System.out.println(autrelist);
ça affichera en console :
```
[[1, 2, 3, 4]]
```
.
Ce n'est toujours pas une List, c'est une représentation d'une List. Et cette List ne contient pas de List. Elle contient une chaîne de caractères, qui est la représentation d'une List.

Normalement, si tu n'as pas de crochet en entrée dans ton fichier, tu ne devrais pas avoir de crochet dans aucun élément suivant un split des chaines de caractères lues dans ce fichier.

Le seul moyen de l'avoir c'est d'avoir à un moment utiliser la représentation chaîne de caractères d'une List, ce qui normalement ne devrait pas avoir été fait si au final ce sont bien les éléments de la liste que tu veux obtenir. Il y a un aller et retour vers chaîne de caractères qui n'auraient pas dû être fait.

Cet aller est retour peut provenir de copier/coller de ce qu'on voit en console, ou d'écriture dans des fichiers en écrivant directement la représentation chaîne de caractères de la liste, au lieu d'écrire chaque élément de la liste, on d'un toString() qu'il n'aurait pas dû être fait. On peut contourner ce genre de problème en changeant la façon d'écrire les listes en console ou dans des fichiers, ou en n'utilisant pas toString() quand on veut conserver la List.

Quoiqu'il en soit, si à cause de je ne sais quel traitement tu finis par obtenir une représentation de List en chaîne de caractères obtenues directement par la méthode toString() et que tu veux effectuer de nouveau un split dessus, et que tu as des caractères gênants, tu peux toujours les supprimer avant (par exemple avec les méthode replace/replaceAll de String), ou après. La méthode trim() peut être utile également pour supprimer les espaces en début et fin de chaîne.

c'est ça la partie du code où j'ai appelé la méthode TimeStamp qui me retourne une liste

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
String[] ary = new String[0]; 
		for(int i=0; i<4; i++) {
			   for(int j=0; j<matrix[i].length; j++) {	
				   result.add(Acces(matrix[i][j], lines));
 
			   }
		}
 
				   for(int h=0; h<result.size(); h++) 
				   {
					   ary = result.get(h).split(",");
//						  System.out.println(result.get(h));		  
					for(int a=0; a<4; a++) 
					{
								  for(int b=0; b<tableau1[a].length; b++) 
								  {
 
									  s1= tableau1[a][b].split(" ");
									  list=TimeStamp(s1, ary);
 
 
 
									  if (list.isEmpty() == false) {
										  System.out.println(list);}

lorsque j'essaye de l'afficher vers la fin ça me donne

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
[ 1217166360,  1217183040]
[ 1217144220,  1217149800,  1217190480,  1217193240,  1217209680]
[ 1217125080,  1217144220,  1217149800,  1217166360,  1217167560,  1217170140,  1217183040,  1217190480,  1217190480,  1217193240,  1217208660,  1217209680,  1217212620,  1217216160,  1217220300]]
[ 1216473720]
[ 1216489440,  1216489500,  1216496100,  1216497420]]
[ 1216473720,  1216489440]
[ 1216471380,  1216482780,  1216489440,  1216489500,  1216491840,  1216496100,  1216497420]]
[ 1217305140,  1217312580]]
[ 1217312580]]
[ 1217282220,  1217297280]
[ 1217282220,  1217297280,  1217301360]
[ 1217366040,  1217413740]]
[ 1217394480]
[ 1217366040,  1217366340,  1217413740]]
[ 1217358420,  1217366340,  1217392200,  1217394480,  1217412120]
[ 1217511360]
[ 1217505420]
[ 1217505420,  1217516820,  1217528280]]
[ 1217562720]]
[ 1217548920]
[ 1217814540,  1217867040,  1217874720]
[ 1217876280]]
[ 1217848740,  1217851440,  1217859300,  1217864760,  1217867040,  1217872680,  1217874720]
[ 1217814300,  1217848740,  1217851440,  1217853060,  1217856540,  1217859300,  1217860260,  1217862660,  1217864760,  1217872680,  1217876280]]
[ 1216466220]]
[ 1216461300,  1216463520]
[ 1216461300,  1216463520,  1216466220]]
[ 1216473720]
[ 1216489440,  1216489500,  1216496100,  1216497420]]
[ 1216473720,  1216489440]
[ 1216471380,  1216482780,  1216489440,  1216489500,  1216491840,  1216496100,  1216497420]]
[ 1216728000]
[ 1216688340,  1216708860,  1216720020,  1216733400,  1216782900,  1216833720]
[ 1216677780,  1216688340,  1216708860,  1216720020,  1216728000,  1216733400,  1216782900,  1216833720,  1216992180]]
[ 1217305140,  1217312580]]
[ 1217312580]]
[ 1217282220,  1217297280]
[ 1217282220,  1217297280,  1217301360]
[ 1217338860,  1217339340]]
[ 1217324820,  1217338860,  1217339340]]
[ 1217366040,  1217413740]]
[ 1217394480]
[ 1217366040,  1217366340,  1217413740]]
[ 1217358420,  1217366340,  1217392200,  1217394480,  1217412120]
[ 1217641140,  1217796720,  1217803140]]
[ 1217578800,  1217579160,  1217582880,  1217586540,  1217592420,  1217596200,  1217641140,  1217761740,  1217765160,  1217766300,  1217768580,  1217770020,  1217772000,  1217775600,  1217779080,  1217787780,  1217796720,  1217803140]]
[ 1216466220]]
[ 1216461300,  1216463520]
[ 1216461300,  1216463520,  1216466220]]
[ 1216473720]
[ 1216489440,  1216489500,  1216496100,  1216497420]]
[ 1216473720,  1216489440]
[ 1216471380,  1216482780,  1216489440,  1216489500,  1216491840,  1216496100,  1216497420]]
[ 1216621260]
[ 1216517700,  1216621260,  1216633980]]
[ 1216728000]
[ 1216688340,  1216708860,  1216720020,  1216733400,  1216782900,  1216833720]
[ 1216677780,  1216688340,  1216708860,  1216720020,  1216728000,  1216733400,  1216782900,  1216833720,  1216992180]]
[ 1217166360,  1217183040]
[ 1217144220,  1217149800,  1217190480,  1217193240,  1217209680]
[ 1217125080,  1217144220,  1217149800,  1217166360,  1217167560,  1217170140,  1217183040,  1217190480,  1217190480,  1217193240,  1217208660,  1217209680,  1217212620,  1217216160,  1217220300]]
[ 1217305140,  1217312580]]
[ 1217312580]]
[ 1217282220,  1217297280]
[ 1217282220,  1217297280,  1217301360]
[ 1217366040,  1217413740]]
[ 1217394480]
[ 1217366040,  1217366340,  1217413740]]
[ 1217358420,  1217366340,  1217392200,  1217394480,  1217412120]
[ 1217511360]
[ 1217505420]
[ 1217505420,  1217516820,  1217528280]]

j'ai pas compris d'où viennent les accolades supplémentaires

Le problème c'est là :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
static String Acces(int nb, List<List<String>> liste) {
 
		if (nb < liste.size()) 
		{
			String str = liste.get(nb).toString();
			return str;
		} 
		else 
		{
			return new String();
		}
	}

liste est une List de List de String. Donc liste.get(nb) est une List de String, donc liste.get(nb).toString() est un représentation de liste en chaîne de caractères.

Pourquoi donc ce toString() ici ?

Surtout que :

Code:

1
2
3
4
5
6
7
8
9
10
List<String> result = new ArrayList<>();
 
 
 
		String[] ary = new String[0]; 
		for(int i=0; i<3; i++) {
			   for(int j=0; j<matrix[i].length; j++) {	
				   result.add(Acces(matrix[i][j], lines));
			   }
		}

et ensuite :

Code:

1
2
3
 
				   for(int h=0; h<result.size(); h++)  {
					   ary = result.get(h).split(",");

Exactement ce que je disais.

Si tu fais :

Code:

1
2
3
4
5
6
7
8
9
static List<String> Acces(int nb, List<List<String>> liste) {
 
    if (nb < liste.size()) {
        return liste.get(nb);
    } 
    else {
	return new ArrayList<>();
    }
}

Code:

1
2
3
4
5
6
7
8
List<List<String>> result = new ArrayList<>();
 
String[] ary = new String[0]; 
for(int i=0; i<3; i++) {
    for(int j=0; j<matrix[i].length; j++) {	
        result.add(Acces(matrix[i][j], lines));
    }
}

Code:

1
2
3
4
 for(int h=0; h<result.size(); h++) {
     ary = result.get(h).toArray(new String[result.get(h).size()]);
     /*...*/
}

tu n'auras plus de soucis.

ou alors, si tu tiens à cette aller-retour List/String :

Code:

1
2
3
4
5
6
7
8
9
static String Acces(int nb, List<List<String>> liste) {
 
		if (nb < liste.size()) {
			return liste.get(nb).stream().collect(Collectors.joining(","));
		} 
		else {
			return "";
		}
	}

merci beaucoup, le problème est résolu en corrigeant la méthode Acces

Code:

1
2
3
4
5
6
7
8
9
static String Acces(int nb, List<List<String>> liste) {
 
		if (nb < liste.size()) {
			return liste.get(nb).stream().collect(Collectors.joining(","));
		} 
		else {
			return "";
		}
	}