String avec retour à la ligne tous les '100' caractères

**Portugues13** · 04/06/2012, 14h49

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** · 04/06/2012, 15h05

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** · 04/06/2012, 15h15

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** · 04/06/2012, 15h29

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

**Portugues13** · 04/06/2012, 15h45

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** · 04/06/2012, 17h30

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.

**Fred_34** · 04/06/2012, 18h36

Envoyé par 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.

Ne faut-il pas utiliser indexOf plutot que lastIndexOf ?

Cette méthode est un peu plus rapide :

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 static String formatString(String lines) {
    final int NB_MAX = 100;
    StringBuilder maChaine = new StringBuilder(lines);
    int index = 0;
 
    do {
      index = maChaine.indexOf(" ", index + NB_MAX);
      if (index < 0) {
        break;
      }
      maChaine.setCharAt(index, '\n');
    }
    while (true);
    return maChaine.toString();
 
  }

**thelvin** · 04/06/2012, 18h52

Envoyé par Fred_34

Ne faut-il pas utiliser indexOf plutot que lastIndexOf ?

?

Mais... Le but est de découper en lignes qui ne dépassent pas les 100 caractères. Dans ce cas il faut chercher de la fin vers le début, non ?
On pourrait faire une recherche incrémentale à la limite, mais ce serait plus compliqué et pas spécialement plus efficace.

Envoyé par Fred_34

Cette méthode est un peu plus rapide :

Bien vu. Après tout il ne s'agit que de remplacer quelques caractères dans la chaîne. Ce sera plus efficace de faire exactement ça.

**Fred_34** · 04/06/2012, 19h35

Envoyé par thelvin

Mais... Le but est de découper en lignes qui ne dépassent pas les 100 caractères. Dans ce cas il faut chercher de la fin vers le début, non ?

Oups...
Effectivement ta méthode fait des lignes de 100 ou moins

. La mienne fait des lignes de 100 ou plus

Pour la peine, je t'ai trouvé un bug :
Si au milieu d'un document il y a une ligne de 100 caractères sans espace, ta méthode s’arrête

.

**thelvin** · 04/06/2012, 21h35

Envoyé par Fred_34

Pour la peine, je t'ai trouvé un bug :
Si au milieu d'un document il y a une ligne de 100 caractères sans espace, ta méthode s’arrête

.

Je sais, il vaudrait mieux lancer une Exception, j'imagine. Mais en réalité il faudrait voir quel est le comportement attendu dans ce cas.
Le problème présuppose beaucoup que c'est un cas qui n'arrive pas.

**Portugues13** · 05/06/2012, 09h45

Bonjour et merci à vous.

Envoyé par Fred_34

Cette méthode est un peu plus rapide :

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 static String formatString(String lines) {
    final int NB_MAX = 100;
    StringBuilder maChaine = new StringBuilder(lines);
    int index = 0;
 
    do {
      index = maChaine.indexOf(" ", index + NB_MAX);
      if (index < 0) {
        break;
      }
      maChaine.setCharAt(index, '\n');
    }
    while (true);
    return maChaine.toString();
 
  }

Je ne savais pas qu'on pouvait utiliser un break dans un do-while tiens.

Par contre j'ai l'impression que s'il n'y a pas d'espaces, on pourrait tout à fait se retrouver avec une seule ligne, je me trompe?
Je ne sais pas si vous l'aviez remarqué mais justement j'ai essayé de gérer ce cas là, et dans cette éventualité je ne me pose pas de questions, je coupe à 'NB_MAX' caractères. Et à ce moment là, pourrions nous faire ceci?

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) {
    final int NB_MAX = 100;
    StringBuilder maChaine = new StringBuilder(lines);
    int index = 0,indexTemp=0;
 
    while (index+NB_MAX < maChaine.lenght()-1){
        index = maChaine.indexOf(" ", index + NB_MAX);
        if (index < 0) {
            index = indexTemp + NB_MAX;
            maChaine.insert(index+1,'\n');
        }
        else
            maChaine.setCharAt(index, '\n');
 
        indexTemp = index;
    }
 
    return maChaine.toString();
 
  }

Bien évidemment cela ne change pas le fait que cette méthode permet d'obtenir des lignes>=100 caractères.

Quand à votre méthode thelvin, Fred_34 a soulevé les 2 questions que justement je me posais:

•Utiliser indexOf() plutôt que lastIndexOf(). Si on utilise lastIndexOf(char,fromIndex) le dernier mot se retrouvera forcément tout seul non?

•En cas d'une chaine de plus de 100 caractères la méthode s'arrête.

Cordialement,

**Fred_34** · 05/06/2012, 11h04

Envoyé par Portugues13

Quand à votre méthode thelvin, Fred_34 a soulevé les 2 questions que justement je me posais:

•Utiliser indexOf() plutôt que lastIndexOf(). Si on utilise lastIndexOf(char,fromIndex) le dernier mot se retrouvera forcément tout seul non?

Il faut juste modifier le while

Envoyé par Portugues13

•En cas d'une chaine de plus de 100 caractères la méthode s'arrête.

Il ne faut plus s’arrêter mais couper lorsqu'on ne trouve pas d'espace.

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

**thelvin** · 05/06/2012, 11h16

Envoyé par Portugues13

•Utiliser indexOf() plutôt que lastIndexOf(). Si on utilise lastIndexOf(char,fromIndex) le dernier mot se retrouvera forcément tout seul non?

J'ai effectivement un bug qui met toujours le dernier mot tout seul, mais ce n'est pas à cause de lastIndexOf(), c'est juste que je n'y ai pas pensé.

Le but est de faire des lignes qui ne dépassent pas 100 caractères, non ?
Dans ce cas, on ne peut pas chercher au-delà du 100e caractère, il faut chercher avant le 100e caractère. Donc lastIndexOf().

Envoyé par Portugues13

•En cas d'une chaine de plus de 100 caractères la méthode s'arrête.

Parce qu'on a pas décidé ce qu'il fallait faire dans ce cas. C'est un cas aux limites, ce sera forcément moins élégant de le gérer.

Voici comment je préférerais faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
// Tant que ce qui reste est plus grand que la taille max d'une ligne
while(maChaine.length() - index > NB_MAX) {
  int spaceIndex = maChaine.lastIndexOf(" ", index + NB_MAX);
  if(spaceIndex < index) { // pas trouvé d'espace pour couper. On coupe au max.
    maChaine.insert(index + NB_MAX, '\n');
    index += NB_MAX + 1;
  } else {
    maChaine.setCharAt(spaceIndex, '\n');
    index = spaceIndex + 1;
  }
}

**Portugues13** · 05/06/2012, 12h18

Merci.

Par contre, ôtez moi d'un doute.
Lorsqu'on fait

Code :

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

maChaine.lastIndexOf(' ',index+NB_MAX)

Est-ce que ça va chercher le caractère 'espace' entre les index 0 et 'index+NB_MAX' ou c'est entre 'index+NB_MAX' et maChaine.lenght()? (ou encore autre chose?...)
Parce que justement je ne suis pas sûr d'avoir bien compris le fonctionnement de cette méthode et ça m'empêche de bien comprendre votre code.

Cordialement,

**thelvin** · 05/06/2012, 13h03

Envoyé par Portugues13

Par contre, ôtez moi d'un doute.
Lorsqu'on fait

Code :

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

maChaine.lastIndexOf(' ',index+NB_MAX)

Est-ce que ça va chercher le caractère 'espace' entre les index 0 et 'index+NB_MAX' ou c'est entre 'index+NB_MAX' et maChaine.lenght()? (ou encore autre chose?...)
Parce que justement je ne suis pas sûr d'avoir bien compris le fonctionnement de cette méthode et ça m'empêche de bien comprendre votre code.

Entre 'index+NB_MAX' et 0.

Ça s'appelle "last index of". Et sa JavaDoc est ici.

**Portugues13** · 05/06/2012, 14h12

Envoyé par thelvin

Entre 'index+NB_MAX' et 0.

Ça s'appelle "last index of". Et sa JavaDoc est ici.

J'avais lu la JavaDoc mais justement, tel que je l'avais compris, 'index+NB_MAX' c'était l'index de départ, en d'autres termes on prenait un substring entre 'index+NB_MAX' et la fin de la chaine.

Enfin bon j'ai la solution qu'il me fallait et je remercie les personnes qui ont participé à ce sujet!

Je marque comme Résolu.

**thelvin** · 05/06/2012, 17h16

L'index de départ, oui, mais pour aller vers le début, pas vers la fin. J'ai du mal à croire qu'on puisse comprendre autre chose en lisant la JavaDoc. Déjà que rien qu'avec le nom et en raisonnant par complétude avec les indexOf() -_-°...

String avec retour à la ligne tous les '100' caractères

avec Java

Discussions similaires

Partager

Partager