Est la concaténation avec une chaîne vide pour faire une chaîne de conversion vraiment si mauvais?

Disons que j'ai deux char variables, et plus tard je veux concaténer une chaîne de caractères. C'est comment j'allais le faire:

char c1, c2;
//...

String s = "" + c1 + c2;

J'ai vu des gens qui disent que la "" + "truc" est "moche", etc, et que vous devez utiliser String.valueOf ou Character.toString à la place. Je préfère cette construction parce que:

  • Je préfère l'utilisation d'une langue plutôt la fonction d'appel d'API si possible
    • En général, n'est pas la langue généralement plus stable que l'API?
    • Si le langage ne cache appel d'API, puis encore plus forte raison de le préférer!
      • Plus abstrait! Le masquage est bon!
  • J'aime que la c1 et c2 sont visuellement sur le même niveau
    • String.valueOf(c1) + c2 suggère quelque chose de spécial à propos de c1
  • C'est plus court.

Est-il vraiment un bon argument pourquoi String.valueOf ou Character.toString est préférable de "" +?

Anecdote: dans java.lang.AssertionError, la ligne suivante apparaît 7 fois, chacun avec un type différent:

    this("" + detailMessage);
  • Bien sûr String.valueOf(c1) + c2 serait bizarre, si vous allez dans cette voie, vous devez écrire String.valueOf(c1) + String.valueOf(c2)
  • vous pouvez écrire new String(new char[] {c1, c2})
  • ad Trivia: le Java SE bibliothèques de base ne sont pas exactement une fontaine de bon style d'écriture, c'est bien connu 😉
  • Sauer ouais c'est une autre façon de faire. Je voulais juste faire remarquer qu'il est un peu absurde de convertir un mais pas l'autre. Il serait, comme l'OP dit à juste titre, à tort suggérer que quelque chose de spécial qui se passe.
  • Regardez ici pour une question connexe: stackoverflow.com/questions/1572708/...
InformationsquelleAutor polygenelubricants | 2010-03-24
  1. 25

    Vos arguments sont bons; c'est l'un des plus expressifs les zones du langage Java, et le "" + idiome semble bien ancrée, comme vous l'avez découvert.

    Voir La concaténation de chaîne dans le JLS. Une expression comme

    "" + c1 + c2

    est équivalent à

    new StringBuffer().append(new Character(c1).toString())
                  .append(new Character(c2).toString()).toString()

    sauf que tous les objets intermédiaires ne sont pas nécessaires (donc l'efficacité n'est pas un motif). La spec dit qu'une application peut utiliser la StringBuffer ou pas. Depuis cette fonctionnalité est intégrée à la langue, je ne vois pas de raison d'utiliser le plus prolixe forme, surtout dans un marché déjà détaillé de la langue.

    • En fait, non. JL explique de cette façon, mais le compilateur met en œuvre différemment. L'Éclipse compilateur produit du bytecode équivalente à new StringBuilder().append(c1).append(c2).toString (), Le compilateur javac (1.5) produit du bytecode équivalente à new StringBuilder().append("").append(c1).append(c2).toString()
    InformationsquelleAutor Josh Lee
  2. 19

    Le problème avec cette construction est qu'elle n'a généralement pas d'exprimer l'intention.

    Il représente la concaténation d'une Chaîne par une autre valeur, mais la concaténation n'est généralement pas le but de cette ligne.

    Dans le cas particulier qui vous l'a démontré, la concaténation est en fait l'objectif, de sorte que ce code ne exprimer l'intention.

    Dans l'utilisation plus fréquente de cette approche (String s = "" + intValue;), la concaténation est simplement toléré côté-effet, tandis que la conversion de intValue est l'objectif réel. Et un simple String.valueOf(intValue) exprime l'intention beaucoup plus claire.

    • Je ne le pense pas. "" + x est extrêmement commun, l'intention doit être claire.
    • +1 pour le bon argument; toujours en désaccord, cependant.
    • si l'intention est seulement clair, quand vous avez vu exactement la construction de nombreuses fois avant, alors ce n'est pas évident en tant que tel. Il prouve seulement que la reconnaissance des formes des œuvres.
    • juste assez!
    • Je dirais que presque chaque programmeur java a vu exact de construire beaucoup de fois avant, comme c'est probablement l'une des premières choses qu'ils apprennent. Pour ceux qui n'ont pas, ils sont certainement aller le voir à de nombreuses reprises dans l'avenir et va probablement prendre sur rapide.
    • ne pas sous-estimer le nombre de développeurs inexpérimentés là, et combien d'entre eux ont à maintenir le code existant.
    • permettez-moi d'essayer de la reformuler votre argument: "Ce n'est pas laid, parce que c'est commun." Ce n'est pas le droit de me.
    • Je n'ai pas dit qu'il n'était pas laid. De plus comme "C'est incroyablement commun et probablement ne va pas aller loin."
    • alors j'ai mal lu votre commentaire, désolé. Mais est-ce à dire qu'il doit être utilisé?
    • Je pense que vous avez déjà donné une très approprié réponse à cette question 🙂

    InformationsquelleAutor Joachim Sauer
  3. 4

    Je préfère utiliser String.valueOf pour unique conversions - mais dans votre cas, vous voulez vraiment la concaténation.

    Cependant, je dirais que cette version serait de supprimer toute ambiguïté potentielle:

    String s = c1 + "" + c2;

    De cette façon, il n'y a aucune possibilité, même à distance, de quelqu'un qui envisage de savoir si c1 et c2 sont ajoutés avant la concaténation.

    InformationsquelleAutor Jon Skeet
  4. 2

    À mon avis, "" + x est très lisible, court et précis pour le moment. Je préfère ça à plus construit comme String.valueOf. Le comportement est bien défini et il est donc communément en usage que j'ai du mal à appeler cela un hack à tous.

    La seule chose que je serais un peu inquiet au sujet de la performance et je suis très positif qu'il n'est pas question d'habitude (même si je n'ai pas de mesurer ou de regarder le binaire). Il ya aussi une bonne chance que ce genre de concat est optimisée, car il devrait être facile de le détecter (c'est juste une supposition bien).

    • il est très important si votre code est exécuté des centaines de milliers de fois dans une boucle.
    • Personne ne voulait l'utiliser dans une boucle, en boucle, vous êtes toujours en utilisant les plus connus du code performant. Dans 99% des cas, ce n'est pas un problème. La lisibilité dans le cas général est beaucoup plus important, de l'omi.
    InformationsquelleAutor mafu
  5. 2

    Je pense que dans "" + var la + est effectivement surchargé pour faire la conversion:

    Le langage Java fournit un soutien spécial pour l'opérateur de concaténation de chaîne ( + ), et pour la conversion des autres objets à cordes. La concaténation de chaîne est mise en œuvre par le StringBuilder(ou StringBuffer) de la classe et de sa méthode append. Chaîne de conversions sont mis en œuvre par le biais de la méthode toString, défini par l'Objet et héritées par toutes les classes en Java. Pour plus d'informations sur la concaténation de chaîne et de conversion

    Donc pas de différence et pas de problème à partir d'un point de vue technique.

    Forme d'une lisibilité point de vue - c'est une question de préférence personnelle ou convenu style de codage au sein de l'équipe.

    • J'ai juste ajouté le [codage-style] balise à la question; qu'est ce que cela est surtout sur.
    InformationsquelleAutor Bozho
  6. 2

    Ce sujet

    new String(new char[] {a, b})

    et si vous le faites beaucoup vous pouvez créer une classe "Cordes" avec:

    public static String valueOf(char... chars) {
    return new String(chars);
}

    Votre ligne serait alors lire

    String s = Strings.valueOf(a, b);

    Belle et courte.

    Édité

    Un meilleur nom peut être:

    String s = Chars.asString(a, b);
    • Il devrait également être très rapide, car la seule chose qui doit être fait est un tableau de copier ce qui est assez rapide.
    • c'est une bonne alternative.
    • -1 personne ne Peut dire ce qu'il fait sans regarder la méthode appelée. Merci de refactoriser!
    • Toutes les suggestions? Constructif la critique est toujours la bienvenue.
    • Je serais probablement le nom de la classe CharHelper (CharUtils est un autre candidat) et la méthode charsToString, rendant la ligne String s = CharHelper.charsToString(a, b)
    • Un commentaire javadoc serait suffisant à mon avis. Il ya beaucoup de méthodes dans le jdk qui sont inutiles sans description. De disposer d'une méthode dans une classe appelée Chaînes qui prend un char tableau et crée une Chaîne de caractères semble relativement simple pour moi. Vous suggestion est trop verbeux. Caractères.asString(char... caractères) peut être une bonne alternative.

    InformationsquelleAutor whiskeysierra
  7. 1

    À moins que votre application a besoin chaque once de performance, d'écrire le code qui est plus rapide à écrire et plus facile à lire. "" + est plus lente à exécuter la syntaxe, mais il semble certainement plus facile à lire à chaque fois que je l'ai utilisé.

    InformationsquelleAutor Dean J
  8. 1

    La "" + var style a un très gros problème à mon avis. Il utilise juste la méthode toString de la var. Donc, si vous changez le type de var à autre chose, vous n'obtiendrez pas une exception. Un bel exemple, j'ai juste rencontré, c'est que le type a été modifié à partir de int à Optional<Integer>. Le code compile bien, mais vous obtenez un résultat complètement différent.

    InformationsquelleAutor Chris
  9. 0

    La meilleure façon de le savoir est de compiler /décompiler votre code, j'ai utilisé Jad http://en.wikipedia.org/wiki/JAD_(JAva_Decompiler) pour cela, vous verrez que votre expression a été converti en

    String s = (new StringBuilder()).append("").append(ci).append(c2).toString();

    Comme vous pouvez le voir javac inclus append (""), mais son coût est négligeable, en notant est ajouté à l'interne StringBuilder de la mémoire tampon, vous pouvez vérifier StringBuilder source

    InformationsquelleAutor Evgeniy Dorofeev