Discussion :

[okoax]

Bonjour,

ayant rencontré un souci avec split de String sur les chaines de caractere exemple :

ma chaine A="aaaaaaaaaXXXaaaaaaaaXXaaaaaaaaX"
ma chaine B="XXX"

A.split(B) semblait ne pas fonctionner correctement (normal avec les regex,patern,matches ...)

je viens de finir d'ecrire une methode similaire qui semble marcher :

je la soumet donc aux critiques (amelioration) et à ceux qui en on besoin :

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
30
31
32
33
34
35
 
 
public String[] monSplit(String chaine,String sp){
 
  int indice = 0;
 
  int longueur_sp = sp.length();
 
  Vector table_vec = new Vector();
 
  for(int i=0;i<chaine.length();i++){
     indice = chaine.indexOf(sp);
     if(indice == -1){
        table_vec.addElement(chaine);
        break;
     }else{
        table_vec.addElement(chaine.substring(0,temp));
        chaine = chaine.substring(indice+longueur_sp);
     }	
  }
 
return convert(table_vec.toArray());		
 
}
 
public String[] convert(Object[] tab){
 
 int taille = tab.length;
 String[] resultat = new String[taille];
 
 for(int i = 0 ; i <taille ; i++)
      resultat[i] = tab[i].toString();
 
 return resultat;
}

[leminipouce]

Pour commencer, j'utiliserai un cast explicite plutôt que ta méthode convert, genre ça (au passage ta variable temp n'existe pas...)

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
	/**
         * @param chaine la String dont on veut supprimer "sp"
         * @param sp la String à supprimer de chaine
         * @return un tableau de String contenant les portions de "chaine" privée de sp 
         */
	public String[] monSplit(String chaine,String sp){
		  int indice = 0;
		  int longueur_sp = sp.length();
		  Vector table_vec = new Vector();
 
		  for(int i=0;i<chaine.length();i++){
		     indice = chaine.indexOf(sp);
		     if(indice == -1){
		        table_vec.addElement(chaine);
		        break;
		     }else{
		        table_vec.addElement(chaine.substring(0,indice));
		        chaine = chaine.substring(indice+longueur_sp);
		     }   
		  }
 
		return (String[])table_vec.toArray();      
	}

[okoax]

en effet remplacez temp par indice

merci pour le cast

[leminipouce]

Ensuite, car je n'utilise pas les Vecteurs (très gourmands en ressources, surtout à cause de la synchronisation -> leur préférer les ArrayList)) et que je fais beaucoup moins d'appels de méthode que toi, je pense que le code suivant sera nettement plus peformant (tapé à la volée, je n'ai pas trop le temps de le tester là... (au niveau des performances)) :

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
	/**
         * @param chaine la String dont on veut supprimer "sp"
         * @param sp la String à supprimer de chaine
         * @return un tableau de String contenant les portions de "chaine" privée de sp 
         */
	public String[] monSplit(String chaine,String sp){
		StringTokenizer st=new StringTokenizer(chaine, sp);
		String[] stringArray=new String[st.countTokens()];
 
		int i=0;
		while(st.hasMoreTokens())
			stringArray[i++]=st.nextToken();
 
		return stringArray;      
	}

Enfin, je dois bien reconnaitre que split c'est du bonheur avec des expressions régulière (je sais, il est fait pour), mais alors avec des choses "plus simple" comme les String, ça devient plus délicat à utiliser...

[okoax]

c'etait aussi pour eviter d'utiliser StringTokenizer car j'avais aussi des souci avec ce dernier

[leminipouce]

Ok, alors si tu tiens à éviter également les StringTokenizer, il faut reconnaitre que les choix vont finir par se limiter un peu

Vu que dans ton premier message tu parles d'amélioration, à ta place, je remplacerai le break; par un booléen. Les break sont déconseillés...
Et je remplacerai également le Vector par un ArrayList, moins gourmand en ressources, plus rapide à l'éxécution.

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
/**
    * @param chaine la String dont on veut supprimer "sp"
    * @param sp la String à supprimer de chaine
    * @return un tableau de String contenant les portions de "chaine" privée de sp
    */
   public String[] monSplit(String chaine,String sp){
        int indice = 0;
        int longueur_sp = sp.length();
        ArrayList table_vec = new ArrayList();
 
        boolean isFinished=false;
        for(int i=0;i<chaine.length() && !isFinished;i++){
           indice = chaine.indexOf(sp);
           if(indice == -1){
              table_vec.addElement(chaine);
              isFinished=true;;
           }else{
              table_vec.addElement(chaine.substring(0,indice));
              chaine = chaine.substring(indice+longueur_sp);
           }   
        }
 
      return (String[])table_vec.toArray();     
   }

[soad]

Et je remplacerai également le Vector par un ArrayList, moins gourmand en ressources, plus rapide à l'éxécution.

Cela dépend... un Vector est un peu plus rapide pour l'insertion d'enregistrement mais en contraire pour la lecture l'arrayList est plus rapide...

[leminipouce]

Es-tu sûr de ce que tu annonces ?

J'ai un collègue qui a fait des test sur le sujet, et la différence de temps d'accès était flagrante, de mémoire, dans tous les cas.

Si on prend en compte le fait que l'accès en écriture éxige, comme l'accès en lecture, une exclusivité, donc une synchronisation pour le vecteur, il me semble logique que le Vecteur soit moins performant (attention, je ne dis PAS moins utile !)

Dès que je le temps, je cherche des preuves et/ou fais des test, et j'infirmerai ou confirmerai ce que j'ai dit.

Si tu as déjà les preuves, je suis preneur

[Gfx]

très gourmands en ressources, surtout à cause de la synchronisation

Depuis le temps qu'on le traine ce mythe... Lis cela : http://www-128.ibm.com/developerworks/java/library/j-jtp04223.html?ca=dgr-lnxw01JavaUrbanLegends
Je ne vais pas m'appesentir sur le sujet, mais les "gains" en performance sont si minimes que dans un cas pareil cela ne fera aucune difference.

Pour en revenir au sujet, pourquoi tu ne peux pas utiliser split() ? Comment veux-tu decouper ta chaine exactement ? Quand il y a 3 X, ou quand tu en rencontres un nombre indetermine ?

[leminipouce]

First of all, microbenchmarks rarely measure what you think they're measuring. In the presence of dynamic compilation, you have no idea what bytecode the JVM decides to convert into native code or when, so you can't really compare apples to apples.

Voilà pourquoi je me suis laisser avoir par les tests de mon collègue !!!

Comme quoi, on se [je me] laisse facilement avoir.

Désolé d'avoir participer à cette fausse rumeur.