Ajout d'un élément à une Seq immuable

Question

Disons que j'ai une séquence de chaînes de caractères en entrée et que je veux obtenir un nouvel objet immuable. Seq qui se compose d'éléments de l'entrée et d'un élément "c" . Voici deux méthodes que j'ai découvertes et qui fonctionnent :

1. assert(Seq("a", "b", "c") == Seq("a", "b") ++ Seq("c")) - le problème avec celui-ci est qu'il semble que l'instanciation d'une séquence temporaire ( Seq("c") ) juste pour le plaisir de l'opération est inutile et entraînera des frais généraux.
2. assert(Seq("a", "b", "c") == List("a", "b") ::: "c" :: Nil) - celui-ci restreint le type de collection d'entrée à un List donc Seq("a", "b") ::: "c" :: Nil ne fonctionnera pas. Il semble également que l'instanciation d'un Nil peut également entraîner des frais généraux

Mes questions sont les suivantes :

1. Existe-t-il un autre moyen d'effectuer cette opération ?
2. Laquelle est la meilleure ?
3. N'est-ce pas ? Seq("a", "b") ::: Nil n'étant pas autorisé une faille des développeurs de Scala ?

Answer 1

Utilisez le :+ (append) pour créer un nouveau Seq usando:

val seq = Seq("a", "b") :+ "c"
// seq is now ("a","b","c")

Note : :+ créera un nouveau Seq objet. Si vous avez

val mySeq = Seq("a","b")

et vous appellerez

mySeq :+ "c"

mySeq sera toujours ("a","b")

Notez que certaines implémentations de Seq se prêtent mieux que d'autres à l'adjonction. List est optimisé pour le prépositionnement. Vector a des opérations d'ajout et de retrait rapides.

::: est une méthode sur List ce qui nécessite un autre List comme paramètre - quels sont les avantages que vous lui voyez en acceptant d'autres types de séquence ? Il faudrait convertir les autres types en une séquence List . Si vous savez que List est efficace pour votre cas d'utilisation, alors utilisez ::: (si vous le devez). Si vous souhaitez un comportement polymorphe, utilisez la fonction générique ++ .

Il n'y a pas de surcharge d'instanciation à l'utilisation de Nil vous ne l'instanciez pas parce que c'est un singleton.