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?
In Java terms, Scala's
Seq would be Java's
List, and Scala's
List would be Java's
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
::, which are the concrete implementations of
So, where Java's
List is an
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).
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.immutable.Seq, and it is the latter one that is the "default" imported into scope.
ParSeq. The latter methods run in parallel where possible, which the former is parent to
ParSeq both, 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.