Il est préférable d’utiliser String.format sur chaîne concaténation en Java ?

Question

Est-il un perceptable différence entre l'utilisation d'une Chaîne de caractères.Le Format et la concaténation de chaîne en Java?

J'ai tendance à utiliser des chaînes de caractères.format mais de temps en temps de dérapage et d'utiliser un concat, je me demandais si l'un est meilleur que l'autre.

La façon dont je le vois Chaîne.Format vous donne plus de puissance dans le "formatage" de la chaîne et la concaténation signifie que vous n'avez pas à vous soucier accidentellement mettre dans un supplément de %s ou manquants.

Chaîne de caractères.le format est également plus courte.

Lequel est le plus lisible dépend de la façon dont votre tête fonctionne.

Answer 1

Je suggère qu'il est préférable d'utiliser des chaînes de caractères.format. La raison principale est que la Chaîne de caractères.le format peut être plus facilement localisées avec texte chargé à partir de fichiers de ressources alors que la concaténation peut pas être localisé sans la production d'un nouvel exécutable avec un code différent pour chaque langue.

Si vous prévoyez votre application d'être localisable vous devez également prendre l'habitude de spécifier l'argument positions pour le format de votre jetons ainsi:

"Hello %1$s the time is %2$t"

Cela peut ensuite être localisé et d'avoir le nom et l'heure de jetons échangé, sans exiger de recompiler le fichier exécutable afin de tenir compte des différents de la commande. Avec l'argument de positions vous pouvez également ré-utiliser le même argument sans la passer dans la fonction deux fois:

String.format("Hello %1$s, your name is %1$s and the time is %2$t", name, time)

Answer 2

A propos de la performance:

  public static void main(String[] args) throws Exception {      
  long start = System.currentTimeMillis();
  for( int i=0;i<1000000; i++){
      String s = "Hi " + i + "; Hi to you " + i*2;
  }
  long end = System.currentTimeMillis();
  System.out.println("Concatenation = " + ((end - start)) + " millisecond") ;

  start = System.currentTimeMillis();
     for( int i=0;i<1000000; i++){
         String s = String.format( "Hi %s; Hi to you %s",i, + i*2);
     }
     end = System.currentTimeMillis();
     System.out.println("Format = " + ((end - start)) + " millisecond");
   }
 

Les résultats du chronométrage sont les suivants:

• Concaténation = 265 millisecondes
• Format = 4141 milliseconde

Par conséquent, la concaténation est beaucoup plus rapide que String.format.

Answer 3

Un problème avec .format est que vous perdez la sécurité des types statiques: vous ne pouvez pas avoir assez d'arguments pour votre format et vous pouvez avoir des types incorrects pour les spécificateurs de format - tous deux entraînant un IllegalFormatException dans l'exécution, vous pourriez vous retrouver avec un code de journalisation qui interrompt la production.

En revanche, les arguments de + peuvent être testés par le compilateur.

Answer 4

Puisqu'il est question de performance, j'ai pensé que je serait bien de l'ajouter dans une comparaison qui inclus StringBuilder. Il est en effet plus rapide que la méthode concat et, naturellement la Chaîne.option de format.

Pour en faire une sorte de pommes avec des pommes comparaison, j'instancier un nouvel objet StringBuilder dans la boucle plutôt qu'à l'extérieur (ce qui est effectivement plus rapide que de le faire juste une instanciation probablement en raison de la surcharge de ré-allocation d'espace pour le bouclage de l'ajouter à la fin d'un constructeur).

    String formatString = "Hi %s; Hi to you %s";

    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s = String.format(formatString, i, +i * 2);
    }

    long end = System.currentTimeMillis();
    log.info("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        String s = "Hi " + i + "; Hi to you " + i * 2;
    }

    end = System.currentTimeMillis();

    log.info("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        StringBuilder bldString = new StringBuilder("Hi ");
        bldString.append(i).append("; Hi to you ").append(i * 2);
    }

    end = System.currentTimeMillis();

    log.info("String Builder = " + ((end - start)) + " millisecond");

• 2012-01-11 16:30:46,058 INFO [TestMain] - Format = 1416 milliseconde
• 2012-01-11 16:30:46,190 INFO [TestMain] - Concaténation = 134 milliseconde
• 2012-01-11 16:30:46,313 INFO [TestMain] - le Générateur de Chaîne = 117 milliseconde

Answer 5

Le plus lisible dépend de la façon dont fonctionne votre tête.

Vous avez votre réponse juste là.

C'est une question de goût personnel.

Je suppose que la concaténation de chaînes est légèrement plus rapide, mais cela devrait être négligeable.