Discussion :

[Portugues13]

Bonjour,


Je suis en train de développer une petite fonction qui, dans une variable String, fait un saut de ligne tous le 100 caractères en essayant de ne pas couper les mots. C'est à dire que s'il faut faire un retour à la ligne au caractère 99 pour ne pas se retrouver avec un début de mot en fin de ligne et sa suite à la ligne d'après, il faut gérer cela.


Pour l'instant j'ai réussi à faire une fonction qui marche mais j'aimerais avoir votre avis, pour savoir si on peut l'améliorer:

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
public static String formatString(String lines){
    String maChaine=lines;
    int NB_MAX=100, i=0, index =-1;
 
    while(i+NB_MAX < lines.length()-1){
        index = maChaine.substring(i, i+NB_MAX).lastIndexOf(' ');
 
        if(index != -1)
            maChaine = maChaine.substring(0, (index+i)+1) + '\n' + maChaine.substring((index+i)+1);
 
        else
            maChaine = maChaine.substring(0, i+1) + '\n' + maChaine.substring(i+1);
 
 
        i+= index+1;
    }
 
 
    return maChaine;
  }

En vous remerciant par avance,

[thelvin]

Il serait sans doute un peu plus simple et un peu plus propre de construire la chaîne dans un StringBuilder au lieu de le faire à coups de +

Pour déterminer où couper les lignes, tu pourrais utiliser lastIndexOf() sur tout le restant de la string, mais en commençant à l'extrême limite autorisée, avec lastIndexOf(int ch, int fromIndex).

[Portugues13]

Bonjour et merci de votre réponse.

Si je comprends bien, je dois créer une variable StringBuilder et construire ma chaîne grâce à la méthode append()?

[thelvin]

Ce serait plus efficace et plus facile à lire, oui.

[Portugues13]

Voici mon nouveau Code:

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
public static String formatString(String lines){
 
    int NB_MAX=100, i=0, index;
    StringBuilder maChaine = new StringBuilder();
 
    while(i+NB_MAX < lines.length()-1){
        //On cherche le dernier index du caractère 'espace'
        index = lines.substring(i, i+NB_MAX).lastIndexOf(' ');
        //Si le caractère a été trouvé
        if(index !=-1){
            //On concaténe la sous-chaine au StringBuilder
            maChaine.append(lines.substring(i, i+index));
            //On met à jour la taille de sous-chaine traitée
            i += index+1;
        }
        //Sinon
        else{
            //On concaténe une sous-chaine contenant 'NB_MAX' caractères au StringBuilder
            maChaine.append(lines.substring(i, i+NB_MAX));
            //On met à jour la taille de sous-chaine traitée 
            i += NB_MAX;
        }
        //On concaténe le caractère 'retour chariot' au StringBuilder
        maChaine.append('\n');
    }
 
    //On renvoie la chaine obtenue
    return maChaine.toString();
  }

Merci de me donner vos impressions.


EDIT: Il faut aussi rajouter un :

Code :

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

maChaine.append(lines.substring(i, lines.length()));

après le while pour qu'il concatène la fin de la chaine.

[thelvin]

Pas mal. Voici ma tentative :

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
// en principe, même taille que la chaîne originale. Autant pré-réserver.
StringBuilder maChaine = new StringBuilder(lines.length());
int index = 0;
 
while(index < lines.length()) {
  int spaceIndex = lines.lastIndexOf(' ', index + NB_MAX);
 
  if(spaceIndex < index) { // inclut < 0, donc espace non trouvé : on a fini
    maChaine.append(lines.substring(index));
    index = lines.length();
  } else {
    maChaine.append(lines.substring(index, spaceIndex));
    maChaine.append('\n');
    index = spaceIndex + 1;
  }
}

Ça évite de faire des substring() à répétition.