Différence entre une séquence et une liste dans Scala

J'ai vu dans de nombreux exemples que parfois une Seq est utilisée, tandis que d'autres fois est la liste ...

Y a-t-il une différence, autre que l'ancien étant un type Scala et la liste venant de Java?

En termes Java, Scala Seqserait Java Listet Scala Listserait JavaLinkedList .

Notez que Seqc'est un trait, qui est équivalent à Java interface, mais avec l'équivalent des méthodes de défense montantes. Scala Listest une classe abstraite qui est étendue par Nilet ::, qui sont les implémentations concrètes de List.

Ainsi, lorsque Java Listest un interface, Scala Listest une implémentation.

Au-delà de cela, Scala Listest immuable, ce qui n'est pas le cas de LinkedList. En fait, Java n'a pas d'équivalent aux collections immuables (la chose en lecture seule garantit que le nouvel objet ne peut pas être changé, mais vous pouvez toujours changer l'ancien et, par conséquent, celui en "lecture seule").

Scala Listest hautement optimisé par le compilateur et les bibliothèques, et c'est un type de données fondamental dans la programmation fonctionnelle. Cependant, il a des limites et est inadéquat pour la programmation parallèle. De nos jours, Vectorc'est un meilleur choix List, mais l'habitude est difficile à briser.

Seqest une bonne généralisation pour les séquences, donc si vous programmez sur des interfaces, vous devriez l'utiliser. Notez qu'il existe en fait trois d'entre eux: collection.Seq, collection.mutable.Seqet collection.immutable.Seq, et il est celui - ci qui est le « défaut » importé dans le périmètre.

Il y a aussi GenSeqet ParSeq. Ces dernières méthodes fonctionnent en parallèle lorsque cela est possible, tandis que la première est parent des deux Seqet ParSeq, étant une généralisation appropriée lorsque le parallélisme d'un code n'a pas d'importance. Ils sont tous deux relativement récents, donc les gens ne les utilisent pas encore beaucoup.

Un Seq est un Iterable qui a un ordre défini d'éléments. Les séquences fournissent une méthode apply()d'indexation, allant de 0 à la longueur de la séquence. Seq possède de nombreuses sous-classes, notamment Queue, Range, List, Stack et LinkedList.

Une liste est une séquence qui est implémentée en tant que liste liée immuable. Il est préférable de l'utiliser dans les cas avec des modèles d'accès dernier entré, premier sorti (LIFO).

Voici la hiérarchie complète des classes de collection de la FAQ Scala :

Seqest un trait qui Listmet en œuvre.

Si vous définissez votre conteneur comme Seq, vous pouvez utiliser n'importe quel conteneur qui implémente Seqtrait.

scala> def sumUp(s: Seq[Int]): Int = { s.sum }
sumUp: (s: Seq[Int])Int

scala> sumUp(List(1,2,3))
res41: Int = 6

scala> sumUp(Vector(1,2,3))
res42: Int = 6

scala> sumUp(Seq(1,2,3))
res44: Int = 6

Notez que

scala> val a = Seq(1,2,3)
a: Seq[Int] = List(1, 2, 3)

Est juste une main courte pour:

scala> val a: Seq[Int] = List(1,2,3)
a: Seq[Int] = List(1, 2, 3)

si le type de conteneur n'est pas spécifié, la structure de données sous-jacente est par défaut List.

Dans Scala, une List hérite de Seq, mais implémente Product ; voici la bonne définition de List :

sealed abstract class List[+A] extends AbstractSeq[A] with Product with ...

[Remarque: la définition actuelle est un peu plus complexe, afin de s'intégrer et d'utiliser le cadre de collecte très puissant de Scala.]

Comme l'a dit @ daniel-c-sobral, List étend le trait Seq et est une classe abstraite implémentée par scala.collection.immutable.$colon$colon(ou ::pour faire court), mais à part les détails techniques, gardez à l'esprit que la plupart des listes et des séquences que nous utilisons sont initialisées sous la forme de Seq(1, 2, 3)ou List(1, 2, 3)qui retournent toutes les deux scala.collection.immutable.$colon$colon, on peut donc écrire:

var x: scala.collection.immutable.$colon$colon[Int] = null
x = Seq(1, 2, 3).asInstanceOf[scala.collection.immutable.$colon$colon[Int]]
x = List(1, 2, 3).asInstanceOf[scala.collection.immutable.$colon$colon[Int]]

En conséquence, je dirais que la seule chose qui importe, ce sont les méthodes que vous souhaitez exposer, par exemple pour ajouter au début, vous pouvez utiliser à ::partir de List que je trouve redondant avec +:de Seq et je persiste personnellement à Seq par défaut.