Difference between a Seq and a List in Scala
Solution 1
In Java terms, Scala's Seq
would be Java's List
, and Scala's List
would be Java's LinkedList
.
Note that Seq
is a trait
, which is equivalent to Java's interface
, but with the equivalent of up-and-coming defender methods. Scala's List
is an abstract class that is extended by Nil
and ::
, which are the concrete implementations of List
.
So, where Java's List
is an interface
, Scala's List
is an implementation.
Beyond that, Scala's List
is immutable, which is not the case of LinkedList
. In fact, Java has no equivalent to immutable collections (the read only thing only guarantees the new object cannot be changed, but you still can change the old one, and, therefore, the "read only" one).
Scala's List
is highly optimized by compiler and libraries, and it's a fundamental data type in functional programming. However, it has limitations and it's inadequate for parallel programming. These days, Vector
is a better choice than List
, but habit is hard to break.
Seq
is a good generalization for sequences, so if you program to interfaces, you should use that. Note that there are actually three of them: collection.Seq
, collection.mutable.Seq
and collection.immutable.Seq
, and it is the latter one that is the "default" imported into scope.
There's also GenSeq
and ParSeq
. The latter methods run in parallel where possible, while the former is parent to both Seq
and ParSeq
, being a suitable generalization for when parallelism of a code doesn't matter. They are both relatively newly introduced, so people doesn't use them much yet.
Solution 2
A Seq is an Iterable that has a defined order of elements. Sequences provide a method apply()
for indexing, ranging from 0 up to the length of the sequence. Seq has many subclasses including Queue, Range, List, Stack, and LinkedList.
A List is a Seq that is implemented as an immutable linked list. It's best used in cases with last-in first-out (LIFO) access patterns.
Here is the complete collection class hierarchy from the Scala FAQ:
Solution 3
Seq
is a trait that List
implements.
If you define your container as Seq
, you can use any container that implements Seq
trait.
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
Note that
scala> val a = Seq(1,2,3)
a: Seq[Int] = List(1, 2, 3)
Is just a short hand for:
scala> val a: Seq[Int] = List(1,2,3)
a: Seq[Int] = List(1, 2, 3)
if the container type is not specified, the underlying data structure defaults to List
.
Solution 4
In Scala, a List inherits from Seq, but implements Product; here is the proper definition of List :
sealed abstract class List[+A] extends AbstractSeq[A] with Product with ...
[Note: the actual definition is a tad bit more complex, in order to fit in with and make use of Scala's very powerful collection framework.]
Solution 5
As @daniel-c-sobral said, List extends the trait Seq and is an abstract class implemented by scala.collection.immutable.$colon$colon
(or ::
for short), but technicalities aside, mind that most of lists and seqs we use are initialized in the form of Seq(1, 2, 3)
or List(1, 2, 3)
which both return scala.collection.immutable.$colon$colon
, hence one can write:
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]]
As a result, I'd argue than the only thing that matters are the methods you want to expose, for instance to prepend you can use ::
from List that I find redundant with +:
from Seq and I personally stick to Seq by default.
opensas
Updated on August 12, 2020Comments
-
opensas over 3 years
I've seen in many examples that sometimes a Seq is being used, while other times is the List...
Is there any difference, other than the former one being a Scala type and the List coming from Java?
-
huynhjl almost 12 yearsRE "Java has no equivalent to immutable collections", although
String
is not a collection, it is an example of immutable classes familiar to Java programmers. -
Daniel C. Sobral almost 12 years@huynhjl That's beside the point. I was drawing parallels between what exists in Java and what exists in Scala, and there just isn't any concept of mutable/immutable collections in Java.
-
Rick-777 almost 12 yearsParSeq is probably little used because its use cases are limited by Amdahl's Law - your speedup from parallelism is limited if the execution time is dominated by its sequential bits. Use with care.
-
jbx over 10 yearsJava actually has the equivalent of immutable collections. Its not that 'well advertised' but its there and when you use generics heavily you are likely to hit some
UnsupportedOperationException
because of this. To create an immutable list in Java you use the Collections.unmodifiableList() and similarly there are other methods for Sets, Maps etc. docs.oracle.com/javase/6/docs/api/java/util/… -
Daniel C. Sobral over 10 years@jbx Not true. If you use these methods, you get something an object that will throw exceptions on methods that modify it, but not an immutable object. If the original object gets modified after the unmodifiable object got created, the unmodifiable object will reflect that. So, unmodifiable, yes, immutable, no.
-
jbx over 10 yearsWell, yes and no. Agreed the language is not designed for pure immutability. I said 'equivalent' because in most cases it can be used to suit the purpose. In fact when you have a generic collection parameter of a certain super type with
extends
and the actual concrete class passed is of a sub-type Java makes use of an unmodifiable collection to enforce the receiving method not to modify it, thus avoiding insertion of an object of a different subtype. Yes the case you are mentioning allows you to modify the object contained in the collection, but for the sake of type safety it still holds. -
Daniel C. Sobral over 10 years@jbx The receiving method cannot keep a reference to the collection it received and assume it will never change, and there's no type in the standard Java library that will guarantee that -- that is immutability. So, for instance, that receiving method cannot guarantee thread safety. And this doesn't even touch the persistent characteristics enabled by immutability. Without all that, it cannot be called "equivalent".
-
DK_ over 10 yearsThough it's hinted at, it's probably worth noting that Scala's List is O(n) for element lookup using indices; so if you need non-sequential lookup use something else, like an IndexedSeq or a Vector.
-
justinhj about 8 years"Vector is a better choice than List" is too general. List has constant time for head, tail and prepend whilst for Vector they are "effectively constant". I'd use List where these 3 operations are enough since it has a little less overhead
-
Daniel C. Sobral about 8 years@justinhj Which ignores locality of reference. Yes, it is too general, but it happens to be true in all but edge cases.
-
Chris Prince over 7 yearsIf
Seq
is a trait, then why can I instantiate it? e.g., why isvar x = Seq(1, 2, 3)
legal? -
musiKk over 7 years@ChrisPrince The
Seq
object inherits anapply
method. -
Daniel C. Sobral over 7 years@ChrisPrince Because
Seq
is both a trait and an object. When you writevar x = Seq(1, 2, 3)
, you are calling theapply
method on the object. -
hdkrus over 5 yearsIs important to point out that Seq is a lazy operation representation while List is a concrete data structure that stores the values in memory. I think this is the most valuable difference.
-
Daniel C. Sobral over 5 years@hdkrus
Seq
is not a lazy operation. It's an interface, whichList
implements. -
hdkrus over 5 years@Daniel, you're completely right. I was thinking in Immutable.js but this is Scala, my bad
-
Peter Krauss over 4 yearsWhere Array (and ArrayBuffer)? It is not kind of Iterable
-
Topa over 2 yearsThis answer shows Array