Ajout d'un élément à une séquence immuable

Question

Disons, j'ai une séquence de chaînes en entrée et je veux obtenir un nouveau Seq immuable qui se compose d'éléments de l'entrée et d'un élément "c". Voici deux méthodes dont j'ai découvert qu'elles fonctionnaient:

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 redondante et entraînera une surcharge
2. assert(Seq("a", "b", "c") == List("a", "b") ::: "c" :: Nil) - celle-ci restreint le type de collection d'entrée à 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:

1. Existe-t-il un autre moyen d'effectuer cette opération?
2. Quel est le meilleur?
3. Seq("a", "b") ::: Nil n'est-il pas autorisé à avoir un défaut des développeurs de Scala?

Answer 1

Utilisez le :+ (ajouter), opérateur pour créer un nouveaSeq en utilisant:

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

Remarque: :+ créera un nouvel objet Seq. Si tu as

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

et vous appellerez

mySeq :+ "c"

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

Notez que certaines implémentations de Seq sont plus adaptées à l'ajout que d'autres. List est optimisé pour le préfixe. Vector a des opérations d'ajout et de pré-ajout rapides.

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

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