Discussion :

[legentil]

Bonjour !!

J'ai un problème pour découper une chaine de caractères...
J'ai une méthode à qui on passe en entrée une String et un délimiteur et qui ressort un tableau de chaine de caractère...

Jusque là, rien de bien compliqué.

j'ai donc tout d'abord utilisé StringTokenizer, qui marche bien dans le cas où ma chaine d'entrée est du type champ1|champ2|....

par contre problème dès que ma chaine d'entrée ressemble plus à champ1&&champ2&&.... bref dès que le délimiteur fait plus d'un caractère...

Je me lance donc dans une 2ème solution, le .split de la classe String
Ce coup ci, le premier cas rate car le délimiteur est "|"... (Vu que c'est une expression régulière il doit interpréter ça en "chaine vide OU chaine vide") et je me retrouve donc avec un tableau par caractère en sortie...

est ce qu'il existe une solution toute faite qui permettrai d'avoir un bon fonctionnement dans tous les cas?? ( j'ai pensé par exemple à une fonction qui serai capable de convertir une chaine en expression régulière ( autrement dit une fonction à qui je passerai | en entrée et qui me sortirai une chaine qui serai interprété dans une expression régulière comme étant le caractère "|") mais je n'ai rien trouvé... pour me permettre de faire marcher correctement la méthode split) mais je n'ai rien trouvé)

Sinon je sais que ça fait pas beaucoup de lignes à coder pour arriver à ce résultat ( beaucoup moins que le nombre de lignes que j'aurai écrites pour expliquer mon problème en tout cas ) mais je suis curieux de savoir si une solution toute faite existe à mon problème et ça réduirai légèrement le code...

Merci d'avance !

[NutellaPiou]

Tu dois déspécialiser les caractères

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
public class Test
{
    public static void main(String []args)
    {
        String machaine = "Boubou|pouet";
        String[] split = machaine.split("\\|");
        for(int i = 0; i < split.length; i++)
            System.out.println(split[i]);
 
        String machaine2 = "Austin&&Power";
        String[] split2 = machaine2.split("&&");
        for(int i = 0; i < split2.length; i++)
            System.out.println(split2[i]);
    }
 
}

Code Résultat :

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

1
2
3
4
5
6
run:
Boubou
pouet
Austin
Power
BUILD SUCCESSFUL (total time: 0 seconds)

[Uther]

Dans une expression régulière les caractère spéciaux peuvent être échappés par un antislash. Cependant les antislash sont également considérés comme des caractères d' échappement dans les Strings java. Il faut les doubler.

Cela donnerait:

Code :

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

chaine.split("\\|");

et

Code :

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

chaine.split("\\&\\&");

[legentil]

Merci pour cette solution mais elle laisse pose de nouveaux problèmes

Déjà oui je suis d'accord pour le double slash devant chaque lettre car si le malin d'utilisateur décide d'avoir comme caractère délimiteur "||" et qu'on utilise le code

Code :

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

1
2
3
4
5
 
String machaine = "Boubou||pouet";
String[] split = machaine.split("\\||");
for(int i = 0; i < split.length; i++)
       System.out.println(split[i]);

on se retrouve avec le 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
B
o
u
b
o
u
 
 
p
o
u
e
t

Pour ce qui est ensuite de mettre un double slash devant chaque lettre, ça résout le problème mais par contre un nouveau se pose !

Si le même malin d'utilisateur décide ce coup ci de prendre la lettre t comme séparateur ( c'est crétin mais pas impossible ) la chaine de caractère "\\t" va donc être interprétée comme "\t", et donc le découpage se fera sur les tabulations et non pas la lettre t....

Code :

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

1
2
3
4
String machaine3 = "chaine1tchaine2";
String[] split3 = machaine3.split("\\t");
for(int i = 0; i < split3.length; i++)
    System.out.println(split3[i]);

donne le résultat :

Code :

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

chaine1tchaine2

Merci pour vos propositions mais pour le moment je fais avec petit bout de code que je me suis fais et qui semble marcher pas mal pour le moment :

Code :

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

1
2
3
4
5
6
7
8
9
fields = new ArrayList<String>();
String lineTemp = new String(line);
while(lineTemp.contains(csvSeparator) && lineTemp.length()>0){
	int index = lineTemp.indexOf(csvSeparator);
	fields.add(lineTemp.substring(0,index));
	lineTemp = lineTemp.substring(index+csvSeparator.length());
}
//add the last field
fields.add(lineTemp);

[Uther]

Dans le cas de la lettre 't' il suffit de ne pas l'échapper. Seul les caractères \.^$?*+|()[]{} ont besoin d'être échapés

[legentil]

Merci je vais essayer comme ça ( mais du coup au final je sais pas si ça simplifiera beaucoup le code par rapport à mon bout de code !! )

[NutellaPiou]

Code :

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

chaine.split("\\&\\&");

T'es pas obligé de mettre les \\ devant je crois. Je viens de tester un simple && et ça fonctionne.

Pour legentil, j'ai pas dit que \\| c'était égal à \\||
Pour que ca fonctionne tu dois déspécialiser chaque | donc ça donne \\|\\|

[Uther]

Merci je vais essayer comme ça ( mais du coup au final je sais pas si ça simplifiera beaucoup le code par rapport à mon bout de code !! )

En fait ce n'est pas si compliqué que ça grâce, encore, aux expressions régulières.
Il faudrait faire ça sur ton séparateur:

Code :

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

separateur = separateur.replaceAll("[\\\\.^$?*+|()\\[\\]{}]", "\\\\$0");

Cela échappera les méta-caractères \.^$?*+|()[]{}

T'es pas obligé de mettre les \\ devant je crois. Je viens de tester un simple && et ça fonctionne.

En effet le "&" a un sens particulier mais seulement a l'intérieur des crochets.
Dans le cas présent, étant donné que les crochets doivent être échappés, il n'est pas nécessaire d'échapper également le "&", même si ça ne fait pas de mal.