Attention aux performances de concaténation de chaînes

1. Concaténation de chaîne avec l'opérateur ( ):
L'utilisation de l'opérateur pour concaténer des chaînes est pratique pour quelques concaténations, mais présente des problèmes de performances pour les opérations à grande échelle en raison de l'immuabilité des chaînes.
Chaque fois qu'une nouvelle chaîne est créée, le contenu de toutes les chaînes précédentes est copié, ce qui entraîne un temps quadratique pour les grandes concaténations.

Exemple incorrect (concaténation répétée avec ) :

public String criaFatura(List<Item> itens) {
    String fatura = "";
    for (Item item : itens) {
        fatura += item.toString();  // ineficiente para grandes listas
    }
    return fatura;
}

2. Utiliser StringBuilder pour améliorer les performances :
Au lieu d'utiliser , utilisez StringBuilder, qui vous permet de modifier les chaînes efficacement, en allouant dynamiquement de la mémoire selon vos besoins.
Le temps de concaténation avec StringBuilder est linéaire, ce qui améliore considérablement les performances.

Exemple correct (utilisation de StringBuilder) :

public String criaFatura(List<Item> itens) {
    StringBuilder fatura = new StringBuilder(itens.size() * 80);  // pré-alocação
    for (Item item : itens) {
        fatura.append(item.toString());
    }
    return fatura.toString();
}

3. Comparaison des performances :
Même après les améliorations apportées à Java 6 pour optimiser l'opérateur, l'utilisation de StringBuilder continue d'être plus efficace. Sur une machine de test, l'utilisation de StringBuilder était 6,5 fois plus rapide que l'opérateur dans un scénario avec 100 éléments.

Exemple d'optimisation sans pré-allocation :

public String criaFatura(List<Item> itens) {
    StringBuilder fatura = new StringBuilder();  // sem pré-alocação
    for (Item item : itens) {
        fatura.append(item.toString());
    }
    return fatura.toString();
}

4. La morale de l'histoire :
Ne l'utilisez pas pour concaténer plusieurs chaînes. Les performances deviennent rapidement inacceptables à mesure que le nombre de concaténations augmente.
Utilisez StringBuilder.append ou des alternatives telles que des tableaux de caractères pour de grands volumes de concaténations.

5. Autres alternatives :
En plus de StringBuilder, vous pouvez envisager d'utiliser des tableaux de caractères pour un traitement à grande échelle ou pour combiner des chaînes plus efficacement, en particulier lorsqu'un contrôle plus précis des performances est nécessaire.

Conclusion :
Utilisez StringBuilder pour concaténer efficacement des chaînes.
Évitez d'utiliser l'opérateur dans des boucles ou pour de gros volumes de chaînes, car les performances se dégradent considérablement à mesure que le nombre de concaténations augmente.

Exemples du livre :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!