Le moyen le plus rapide d'effectuer beaucoup de chaînes de remplacer en Java

Je dois écrire une sorte de parser obtenir une Chaîne de caractères et de remplacer certains ensembles de caractères avec les autres. Le code ressemble à ceci:

noHTMLString = noHTMLString.replaceAll("</p>", "\n");
noHTMLString = noHTMLString.replaceAll("<br/>", "\n\n");
noHTMLString = noHTMLString.replaceAll("<br />", "\n\n");
//here goes A LOT of lines like these ones

La fonction est très long et effectue beaucoup de chaînes remplace. Le problème ici est que cela prend beaucoup de temps parce que la méthode qu'il a appelé à un grand nombre de fois, ce qui ralentit les performances de l'application.

J'ai lu quelques discussions ici sur l'utilisation de StringBuilder comme une alternative, mais il manque de la méthode ReplaceAll et comme il est noté ici N'chaîne.replaceAll() performance souffrent de la chaîne de l'immutabilité? la replaceAll méthode de la classe String fonctionne avec

Correspond au Motif & Matcher et Matcher.replaceAll() utilise un StringBuilder pour stocker, éventuellement, la valeur de retour
donc je ne sais pas si le passage à la classe StringBuilder vraiment réduire le temps d'effectuer les substitutions.

Connaissez-vous un moyen rapide de faire beaucoup de Chaîne de remplacer dans un moyen rapide? Avez-vous des conseils pour ce problème?

Grâce.

MODIFIER: j'ai créer un rapport qui ont un peu de champs avec du texte html. Pour chaque ligne, je vais appeler la méthode qui remplace toutes les balises html et caractères spéciaux à l'intérieur de ces chaînes. Avec un rapport complet elle prend plus de 3 minutes pour analyser l'ensemble du texte. Le problème c'est que je dois appeler la méthode très souvent

source d'informationauteur Averroes | 2010-11-26

12

J'ai trouvé que org.apache.commons.lang.StringUtils est la manière la plus rapide si vous ne voulez pas vous embêter avec le StringBuffer.

Vous pouvez l'utiliser comme ceci:

noHTMLString = StringUtils.replace(noHTMLString, "</p>", "\n");

J'ai fait des tests de performance, il a été fester que mon custom StrinBuffer solution similaire à celle @extraneon proposé.
6

Il ressemble à votre analyse HTML de là, avez-vous bien que sur l'utilisation d'un 3ème partie de la bibliothèque au lieu de ré-inventer la roue?
4

Je suis d'accord avec Martijn à l'aide d'un prêt-solution plutôt que d'analyser vous-même il y a beaucoup de choses intégré dans Java dans le javax.xml package. Une solution élégante serait d'utiliser transformation XSLT pour le remplacer, cela ressemble à un idéal de cas d'utilisation. Cependant, il est compliqué.

Pour répondre à la question, avez-vous songé à l'aide de la expression régulière bibliothèques? Il semble que vous avez beaucoup de choses différentes que vous voulez faire correspondre, et de le remplacer avec la même chose (\n, ou une chaîne vide). En utilisant des expressions régulières, vous pourrait être une expression comme "<br>|<br/>|<br />" ou même plus intelligent comme <br.*?>" pour créer un matcher objet, sur lequel vous pouvez appeler replaceAll.
3

Je suis entièrement d'accord avec Martijn ici. Choisir le bon outil pour le travail.

Si votre fichier n'est cependant pas le HTML, mais ne contient que du code HTML de jetons il existe quelques façons dont vous pouvez accélérer les choses.

Tout d'abord, si une certaine quantité de l'entrée ne contient pas les éléments remplaçables, envisager de commencer avec quelque chose comme:
```
if (!input.contains('<')) {
    return input;
}
```
Deuxièmement, considérons une regex:
```
Pattern p = Pattern.compile( your_regex );
```
Ne pas faire un modèle pour chaque replaceAll ligne, mais essayez de les combiner (regex a un OU opérateur) et laissez Motif d'optimiser la regex. Ne pas utiliser le compilé motif et ne pas compiler à chaque appel, il est assez cher.

Si regexes sont un peu complexe, vous pouvez également mettre en œuvre certaines plus vite (mais potentiellement moins lisible) moteur de remplacement vous-même:
```
StringBuilder result = new StringBuilder(input.length();
for (int i=0; i < input.length(); i++) {
  char c = input.charAt(i);

  if ( c != '<' ) {
    continue;
  }

  int closePos = input.indexOf( '>', i);
  if (closePos == -1) {//not found
    result.append( input.substring(i, input.length());
    return result.toString();
  }
  i = closePos;
  String token = input.substring(i, closePos);
  if ( token.equals( "p/" ) {
    result.append("\\n");
  } else if (token.equals(...)) {
  } else if (...) {
  } 
}
return result.toString();
```
Cela peut avoir quelques erreurs 🙂

L'avantage est que vous avez à parcourir les saisies qu'une seule fois. Le gros inconvénient est qu'il n'est pas du tout facile à comprendre. Vous pouvez également écrire une machine d'état, l'analyse par le caractère de ce que le nouvel état doit être, et ce serait sans doute plus rapide et encore plus de travail.

Vous devez vous connecter pour publier un commentaire.