Advantages of Scala's type system

Question

I am exploring the Scala language. One claim I often hear is that Scala has a stronger type system than Java. By this I think what people mean is that:

Answer 1

The main advantage of the Scala Type system is not so much being stronger but rather being far richer (see "The Scala Type System").
(Java can define some of them, and implement others, but Scala has them built-in).
See also The Myth Makers 1: Scala's "Type Types", commenting Steve Yegge's blog post, where he "disses" Scala as "Frankenstein's Monster" because "there are type types, and type type types".

• Value type classes (useful for reasonably small data structures that have value semantics) used instead of primitives types (Int, Doubles, ...), with implicit conversion to "Rich" classes for additional methods.
• Nonnullable type
• Monad types
• Trait types (and the mixin composition that comes with it)
• Singleton object types (just define an 'object' and you have one),
• Compound types (intersections of object types, to express that the type of an object is a subtype of several other types),
• Functional types ((type1, …)=>returnType syntax),
• Case classes (regular classes which export their constructor parameters and which provide a recursive decomposition mechanism via pattern matching),
• Path-dependent types (Languages that let you nest types provide ways to refer to those type paths),
• Anonymous types (for defining anonymous functions),
• Self types (can be used for instance in Trait),
• Type aliases, along with:
• package object (introduced in 2.8)
• Generic types (like Java), with a type parameter annotation mechanism to control the subtyping behavior of generic types,
  • Covariant generic types: The annotation +T declares type T to be used only in covariant positions. Stack[T] is a subtype of Stack[S] if T is a subtype of S.
  • Contravariant generic types: -T would declare T to be used only in contravariant positions.
• Bounded generic types (even though Java supports some part of it),
• Higher kinded types, which allow one to express more advanced type relationships than is possible with Java Generics,
• Abstract types (the alternative to generic type),
• Existential types (used in Scala like the Java wildcard type),
• Implicit types (see "The awesomeness of Scala is implicit",
• View bounded types, and
• Structural types, for specifing a type by specifying characteristics of the desired type (duck typing).