Java 프로그래머를 위한 Scala 입문 튜토리얼

Java 8에는 클로저 등 몇 가지 예비 함수형 프로그래밍 기능과 새로운 동시 프로그래밍 모델, 고차 함수 및 지연 계산이 포함된 데이터 수집인 Stream이 있습니다. Java 8을 사용해 본 후에도 아직 배울 것이 더 많다고 느낄 수도 있습니다. 그렇습니다. 처음으로 함수형 프로그래밍을 시도한 후에 Scala가 지식에 대한 갈증을 충족시킬 수 있다는 것을 알게 될 것입니다.

Scala 설치

공식 Scala 다운로드 주소에서 다운로드하세요: http://scala-lang.org/download/:

wget -c http://downloads.lightbend.com/scala/2.11.8/scala-2.11.8.tgztar zxf scala-2.11.8.tgz
cd scala-2.11.8./bin/scala
Welcome to Scala version 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_60).
Type in expressions to have them evaluated.Type :help for more information.

scala>

RELP

지금 우리는 명령줄 기반의 대화형 프로그래밍 환경인 Scala RELP를 시작했습니다. 이는 Python 및 Ruby와 같은 동적 언어를 사용하는 학생들에게 매우 일반적인 도구입니다. 그러나 Java 사용자는 처음으로 그것을 볼 때 더 마술적이라는 것을 알게 될 것입니다. 서투른 IDE를 시작하지 않고도 RELP에서 몇 가지 코드 실험을 수행할 수 있는데, 이는 문제를 생각할 때 매우 편리합니다. Java 사용자에게는 좋은 소식이 있습니다. JDK 9에는 RELP 기능이 내장되어 있다는 것입니다.

Scala에서 흔히 사용하는 IDE(통합개발환경)의 경우, scala 플러그인과 scala-ide에는 IDEA를 사용하는 것을 권장합니다.

멀티 코어 프로그래밍, 기능적 기능, 일부 Scala 기반 타사 라이브러리 및 프레임워크(예: Akka, Playframework, Spark, Kafka...)에 대한 향상된 지원 외에도 Scala의 강력한 기능 ), 또한 그 이유는 Java와 원활하게 통합될 수 있기 때문입니다. Java용으로 개발된 모든 라이브러리와 프레임워크는 Scala 환경에 자연스럽게 통합될 수 있습니다. 물론 Scala는 Spring과 같은 Java 환경과도 쉽게 통합될 수 있습니다. 타사 라이브러리의 지원이 필요한 경우 Maven, Gradle, Sbt 및 기타 컴파일 환경을 사용하여 이를 도입할 수 있습니다.

Scala는 Java의 객체지향 기능을 계승하는 동시에 Haskell과 같은 다른 언어의 많은 기능적 기능을 흡수하고 향상시킨 객체지향 프로그래밍 언어입니다.

변수, 기본 데이터 유형

스칼라의 변수는 명시적으로 유형을 지정할 필요는 없지만, 미리 선언해 주어야 합니다. 이는 많은 네임스페이스 오염 문제를 방지합니다. Scala에는 rvalue와 컨텍스트를 기반으로 변수의 유형을 자동으로 추론할 수 있는 매우 강력한 자동 유형 추론 기능이 있습니다. 다음과 같이 직접 값을 선언하고 할당할 수 있습니다.

scala> val a = 1
a: Int = 1

scala> val b = true
b: Boolean = true

scala> val c = 1.0
c: Double = 1.0

scala> val a = 30 + "岁"
a: String = 30岁

불변

(참고: 함수형 프로그래밍에는 불변성이라는 매우 중요한 기능이 있습니다. Scala는 변수의 불변성 외에도 불변 컬렉션 scala .collection.immutable도 정의합니다. ._.)

val은 이것이 상수인 최종 변수임을 의미합니다. 한번 정의하면 변경할 수 없습니다. 따라서 var를 사용하여 정의한 변수는 공통 변수이므로 변경할 수 있습니다. 터미널 인쇄에서 볼 수 있듯이 Scala는 rvalue에서 변수 유형을 자동으로 추론합니다. Scala를 사용하면 동적 언어처럼 코드를 작성할 수 있지만 정적 언어의 컴파일 타임 검사 기능이 있습니다. 이는 Java의 길고 반복적인 유형 선언에 비해 좋은 개선 사항입니다.

(참고: RELP에서는 RELP`의 특징인 val 변수를 재할당할 수 있습니다. 이는 일반 코드에서는 불가능합니다.)

기본 데이터 유형

스칼라의 기본 데이터 유형은 Byte, Short, Int, Long, Float, Double, Boolean, Char 및 String입니다. Java와 달리 Scala는 기본 유형과 int 및 Integer와 같은 박스형 유형을 구분하지 않습니다. Int 유형으로 통합되고 추상화되므로 Scala의 모든 유형은 객체입니다. 컴파일러는 컴파일 타임에 기본 유형을 사용할지 아니면 박스형 유형을 사용할지 자동으로 결정합니다.

문자열

스칼라에는 세 가지 유형의 문자열이 있습니다.

은 각각 일반 문자열이며, 그 특성은 자바 문자열과 동일합니다.

스칼라에서는 큰따옴표 세 개를 연결하는 것도 특별한 의미가 있습니다. 이는 래핑된 콘텐츠가 원본 문자열이며 문자 트랜스코딩이 필요하지 않음을 의미합니다. 이 기능은 정규식을 정의할 때 매우 유용합니다.

컨텍스트의 변수를 직접 참조하고 결과를 문자열에 삽입할 수 있는 "문자열 보간"이라는 문자열 유형도 있습니다.

scala> val c2 = '杨'
c2: Char = 杨

scala> val s1 = "重庆誉存企业信用管理有限公司"
s1: String = 重庆誉存企业信用管理有限公司

scala> val s2 = s"重庆誉存企业信用管理有限公司${c2}景"
s2: String = 重庆誉存企业信用管理有限公司

scala> val s3 = s"""重庆誉存企业信用管理有限公司"工程师"\n${c2}景是江津人"""
s3: String =
重庆誉存企业信用管理有限公司"工程师"
杨景是江津人

연산자와 이름 지정

스칼라의 연산자는 실제로 객체에 정의된 메서드(함수)입니다. 3 + 2는 실제로 다음과 같습니다.3.+(2) . + 기호는 Int 객체에 정의된 메서드입니다. Java와 동일한 연산자(메서드) 지원:

(참고: Scala에서는 메서드 앞의 . 기호와 메서드 양쪽의 괄호를 모호함 없이 생략할 수 있습니다. 이런 식으로 우리는 정의할 수 있습니다. 매우 아름다운 DSL)

==, !=: 비교 연산

!, |, &, ^: 논리 연산

>>, < ;< : 비트 연산

참고

在Scala中，修正了（算更符合一般人的常规理解吧）==和!=运算符的含义。在Scala中，==和!=是执行对象的值比较，相当于Java中的equals方法（实际上编译器在编译时也是这么做的）。而对象的引用比较需要使用eq和ne两个方法来实现。

控制语句（表达式）

Scala中支持if、while、for comprehension（for表达式)、match case（模式匹配）四大主要控制语句。Scala不支持switch和? :两种控制语句，但它的if和match case会有更好的实现。

if

Scala支持if语句，其基本使用和Java、Python中的一样。但不同的时，它是有返回值的。

（注：Scala是函数式语言，函数式语言还有一大特性就是：表达式。函数式语言中所有语句都是基于“表达式”的，而“表达式”的一个特性就是它会有一个值。所有像Java中的? :3目运算符可以使用if语句来代替）。

scala> if (true) "真" else "假"
res0: String = 真

scala> val f = if (false) "真" else "假"
f: String = 假

scala> val unit = if (false) "真"
unit: Any = ()

scala> val unit2 = if (true) "真" 
unit2: Any = 真

可以看到，if语句也是有返回值的，将表达式的结果赋给变量，编译器也能正常推导出变量的类型。unit和unit2变量的类型是Any，这是因为else语句的缺失，Scala编译器就按最大化类型来推导，而Any类型是Scala中的根类型。()在Scala中是Unit类型的实例，可以看做是Java中的Void。

while

Scala中的while循环语句：

while (条件) {
  语句块
}

for comprehension

Scala中也有for表达式，但它和Java中的for不太一样，它具有更强大的特性。通常的for语句如下：

for (变量 <- 集合) {
  语句块
}

Scala中for表达式除了上面那样的常规用法，它还可以使用yield关键字将集合映射为另一个集合：

scala> val list = List(1, 2, 3, 4, 5)list: List[Int] = List(1, 2, 3, 4, 5)

scala> val list2 = for (item <- list) yield item + 1list2: List[Int] = List(2, 3, 4, 5, 6)

还可以在表达式中使用if判断：

scala> val list3 = for (item <- list if item % 2 == 0) yield item
list3: List[Int] = List(2, 4)

还可以做flatMap操作，解析2维列表并将结果摊平（将2维列表拉平为一维列表）：

scala> val llist = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
llist: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))

scala> for {
     |   l <- llist
     |   item <- l if item % 2 == 0
     | } yield item
res3: List[Int] = List(2, 4, 6, 8)

看到了，Scala中for comprehension的特性是很强大的。Scala的整个集合库都支持这一特性，包括：Seq、Map、Set、Array……

Scala没有C-Like语言里的for (int i = 0; i < 10; i++)语法，但Range（范围这个概念），可以基于它来实现循环迭代功能。在Scala中的使用方式如下：

scala> for (i <- (0 until 10)) {
     |   println(i)
     | }
0
1
2
3
4
5
6
7
8
9

Scala中还有一个to方法：

scala> for (i <- (0 to 10))
 print(" " + i) 0 1 2 3 4 5 6 7 8 9 10

match case

模式匹配，是函数式语言很强大的一个特性。它比命令式语言里的switch更好用，表达性更强。

scala> def level(s: Int) = s match {
     |   case n if n >= 90 => "优秀"
     |   case n if n >= 80 => "良好"
     |   case n if n >= 70 => "良"
     |   case n if n >= 60 => "及格"
     |   case _ => "差"
     | }level: (s: Int)Stringscala> level(51)res28: String = 差

scala> level(93)res29: String = 优秀

scala> level(80)res30: String = 良好

可以看到，模式匹配可以实现switch相似的功能。但与switch需要使用break明确告知终止之后的判断不同，Scala中的match case是默认break的。只要其中一个case语句匹配，就终止之后的所以比较。且对应case语句的表达式值将作为整个match case表达式的值返回。

Scala中的模式匹配还有类型匹配、数据抽取、谓词判断等其它有用的功能。这里只做简单介绍，之后会单独一个章节来做较详细的解读。

集合

在java.util包下有丰富的集合库。Scala除了可以使用Java定义的集合库外，它还自己定义了一套功能强大、特性丰富的scala.collection集合库API。

在Scala中，常用的集合类型有：List、Set、Map、Tuple、Vector等。

List

Scala中List是一个不可变列表集合，它很精妙的使用递归结构定义了一个列表集合。

scala> val list = List(1, 2, 3, 4, 5)
list: List[Int] = List(1, 2, 3, 4, 5)

除了之前使用Listobject来定义一个列表，还可以使用如下方式：

scala> val list = 1 :: 2 :: 3 :: 4 :: 5 ::
 Nillist: List[Int] = List(1, 2, 3, 4, 5)

List采用前缀操作的方式（所有操作都在列表顶端（开头））进行，::操作符的作用是将一个元素和列表连接起来，并把元素放在列表的开头。这样List的操作就可以定义成一个递归操作。添加一个元素就是把元素加到列表的开头，List只需要更改下头指针，而删除一个元素就是把List的头指针指向列表中的第2个元素。这样，List的实现就非常的高效，它也不需要对内存做任何的转移操作。List有很多常用的方法：

scala> list.indexOf(3)
res6: Int = 2scala> 0 :: listres8: List[Int] = List(0, 1, 2, 3, 4, 5)

scala> list.reverse
res9: List[Int] = List(5, 4, 3, 2, 1)

scala> list.filter(item => item == 3)
res11: List[Int] = List(3)

scala> listres12: List[Int] = List(1, 2, 3, 4, 5)

scala> val list2 = List(4, 5, 6, 7, 8, 9)
list2: List[Int] = List(4, 5, 6, 7, 8, 9)

scala> list.intersect(list2)
res13: List[Int] = List(4, 5)

scala> list.union(list2)
res14: List[Int] = List(1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9)

scala> list.diff(list2)
res15: List[Int] = List(1, 2, 3)

Scala中默认都是Immutable collection，在集合上定义的操作都不会更改集合本身，而是生成一个新的集合。这与Java集合是一个根本的区别，Java集合默认都是可变的。

Tuple

Scala中也支持Tuple（元组）这种集合，但最多只支持22个元素（事实上Scala中定义了Tuple0、Tuple1……Tuple22这样22个TupleX类，实现方式与C++ Boost库中的Tuple类似）。和大多数语言的Tuple类似（比如：Python），Scala也采用小括号来定义元组。

scala> val tuple1 = (1, 2, 3)tuple1: (Int, Int, Int) = (1,2,3)

scala> tuple1._2res17: Int = 2scala> val tuple2 = Tuple2("杨", " )
tuple2: (String, String) = (杨,景)

可以使用xxx._[X]的形式来引用Tuple中某一个具体元素，其_[X]下标是从1开始的，一直到22（若有定义这么多）。

Set

Set是一个不重复且无序的集合，初始化一个Set需要使用Set对象：

scala> val set = Set("Scala", "Java", "C++", "Javascript", "C#", "Python", "PHP") 
set: scala.collection.immutable.Set[String] = Set(Scala, C#, Python, Javascript, PHP, C++, Java)

scala> set + "Go"
res21: scala.collection.immutable.Set[String] = Set(Scala, C#, Go, Python, Javascript, PHP, C++, Java)

scala> set filterNot (item => item == "PHP")
res22: scala.collection.immutable.Set[String] = Set(Scala, C#, Python, Javascript, C++, Java)

Map

Scala中的Map默认是一个HashMap，其特性与Java版的HashMap基本一至，除了它是Immutable的：

scala> val map = Map("a" -> "A", "b" -> "B")
map: scala.collection.immutable.Map[String,String] = Map(a -> A, b -> B)

scala> val map2 = Map(("b", "B"), ("c", "C"))
map2: scala.collection.immutable.Map[String,String] = Map(b -> B, c -> C)

Scala中定义Map时，传入的每个Entry（K、V对）其实就是一个Tuple2（有两个元素的元组），而->是定义Tuple2的一种便捷方式。

scala> map + ("z" -> "Z")
res23: scala.collection.immutable.Map[String,String] = Map(a -> A, b -> B, z -> Z)

scala> map.filterNot(entry => entry._1 == "a")
res24: scala.collection.immutable.Map[String,String] = Map(b -> B)

scala> val map3 = map - "a"
map3: scala.collection.immutable.Map[String,String] = Map(b -> B)

scala> map
res25: scala.collection.immutable.Map[String,String] = Map(a -> A, b -> B)

Scala的immutable collection并没有添加和删除元素的操作，其定义+（List使用::在头部添加）操作都是生成一个新的集合，而要删除一个元素一般使用 - 操作直接将Key从map中减掉即可。

（注：Scala中也scala.collection.mutable._集合，它定义了不可变集合的相应可变集合版本。一般情况下，除非一此性能优先的操作（其实Scala集合采用了共享存储的优化，生成一个新集合并不会生成所有元素的复本，它将会和老的集合共享大元素。因为Scala中变量默认都是不可变的），推荐还是采用不可变集合。因为它更直观、线程安全，你可以确定你的变量不会在其它地方被不小心的更改。）

Class

Scala里也有class关键字，不过它定义类的方式与Java有些区别。Scala中，类默认是public的，且类属性和方法默认也是public的。Scala中，每个类都有一个“主构造函数”，主构造函数类似函数参数一样写在类名后的小括号中。因为Scala没有像Java那样的“构造函数”，所以属性变量都会在类被创建后初始化。所以当你需要在构造函数里初始化某些属性或资源时，写在类中的属性变量就相当于构造初始化了。

在Scala中定义类非常简单：

class Person(name: String, val age: Int) {
  override def toString(): String = s"姓名：$name, 年龄: $age"
}

默认，Scala主构造函数定义的属性是private的，可以显示指定：val或var来使其可见性为：public。

Scala中覆写一个方法必需添加：override关键字，这对于Java来说可以是一个修正。当标记了override关键字的方法在编译时，若编译器未能在父类中找到可覆写的方法时会报错。而在Java中，你只能通过@Override注解来实现类似功能，它的问题是它只是一个可选项，且编译器只提供警告。这样你还是很容易写出错误的“覆写”方法，你以后覆写了父类函数，但其实很有可能你是实现了一个新的方法，从而引入难以察觉的BUG。

实例化一个类的方式和Java一样，也是使用new关键字。

scala> val me = new Person("杨景", 30)
me: Person = 姓名：杨景, 年龄: 30scala> println(me)
姓名：杨景, 年龄: 30scala> me.name
<console>:20: error: value name is not a member of Person
       me.name
          ^

scala> me.ageres11: Int = 30

case class（样本类）

case class是Scala中学用的一个特性，像Kotlin这样的语言也学习并引入了类似特性（在Kotlin中叫做：data class）。case class具有如下特性：

不需要使用new关键词创建，直接使用类名即可

默认变量都是public final的，不可变的。当然也可以显示指定var、private等特性，但一般不推荐这样用

自动实现了：equals、hashcode、toString等函数

自动实现了：Serializable接口，默认是可序列化的

可应用到match case（模式匹配）中

自带一个copy方法，可以方便的根据某个case class实例来生成一个新的实例

……

这里给出一个case class的使用样例：

scala> trait Person
defined trait Person

scala> case class Man(name: String, age: Int) extends Person
defined class Man

scala> case class Woman(name: String, age: Int) extends Person
defined class Woman

scala> val man = Man("杨景", 30)
man: Man = Man(杨景,30)

scala> val woman = Woman("女人", 23)
woman: Woman = Woman(女人,23)

scala> val manNextYear = man.copy(age = 31)
manNextYear: Man = Man(杨景,31)

object

Scala有一种不同于Java的特殊类型，Singleton Objects。

object Blah {  def sum
(l: List[Int]): Int = l.sum
}

在Scala中，没有Java里的static静态变量和静态作用域的概念，取而代之的是：object。它除了可以实现Java里static的功能，它同时还是一个线程安全的单例类。

伴身对象

大多数的object都不是独立的，通常它都会与一个同名的class定义在一起。这样的object称为伴身对象。

class IntPair(val x: Int, val y: Int)

object IntPair {
  import math.Ordering
  implicit def ipord: Ordering[IntPair] =
    Ordering.by(ip => (ip.x, ip.y))
}

注意

伴身对象必需和它关联的类定义定义在同一个.scala文件。

伴身对象和它相关的类之间可以相互访问受保护的成员。在Java程序中，很多时候会把static成员设置成private的，在Scala中需要这样实现此特性：

class X {
  import X._
  def blah = foo
}
object X {
  private def foo = 42
}

函数

在Scala中，函数是一等公民。函数可以像类型一样被赋值给一个变量，也可以做为一个函数的参数被传入，甚至还可以做为函数的返回值返回。

从Java 8开始，Java也具备了部分函数式编程特性。其Lamdba函数允许将一个函数做值赋给变量、做为方法参数、做为函数返回值。

在Scala中，使用def关键ygnk来定义一个函数方法：

scala> def calc(n1: Int, n2: Int): (Int, Int) = {
     |   (n1 + n2, n1 * n2)
     | }
calc: (n1: Int, n2: Int)(Int, Int)

scala> val (add, sub) = calc(5, 1)
add: Int = 6
sub: Int = 5

这里定义了一个函数：calc，它有两个参数：n1和n2，其类型为：Int。cala函数的返回值类型是一个有两个元素的元组，在Scala中可以简写为：(Int, Int)。在Scala中，代码段的最后一句将做为函数返回值，所以这里不需要显示的写return关键字。

而val (add, sub) = calc(5, 1)一句，是Scala中的抽取功能。它直接把calc函数返回的一个Tuple2值赋给了add他sub两个变量。

函数可以赋给变量：

scala> val calcVar = calc _
calcVar: (Int, Int) => (Int, Int) = <function2>

scala> calcVar(2, 3)
res4: (Int, Int) = (5,6)

scala> val sum: (Int, Int) => Int = (x, y) => x + y
sum: (Int, Int) => Int = <function2>

scala> sum(5, 7)
res5: Int = 12

在Scala中，有两种定义函数的方式：

将一个现成的函数/方法赋值给一个变量，如：val calcVar = calc _。下划线在此处的含意是将函数赋给了变量，函数本身的参数将在变量被调用时再传入。

直接定义函数并同时赋给变量，如：val sum: (Int, Int) => Int = (x, y) => x + y，在冒号之后，等号之前部分：(Int, Int) => Int是函数签名，代表sum这个函数值接收两个Int类型参数并返回一个Int类型参数。等号之后部分是函数体，在函数函数时，x、y参数类型及返回值类型在此可以省略。

一个函数示例：自动资源管理

在我们的日常代码中，资源回收是一个很常见的操作。在Java 7之前，我们必需写很多的try { ... } finally { xxx.close() }这样的样版代码来手动回收资源。Java 7开始，提供了try with close这样的自动资源回收功能。Scala并不能使用Java 7新加的try with close资源自动回收功能，但Scala中有很方便的方式实现类似功能：

def using[T <: AutoCloseable, R](res: T)(func: T => R): R = {  try {
    func(res)
  } finally {    if (res != null)
      res.close()
  }
}val allLine = using(Files.newBufferedReader(Paths.get("/etc/hosts"))) { reader =>  @tailrec
  def readAll(buffer: StringBuilder, line: String): String = {    if (line == null) buffer.toString    else {
      buffer.append(line).append(&#39;\n&#39;)
      readAll(buffer, reader.readLine())
    }
  }

  readAll(new StringBuilder(), reader.readLine())
}

println(allLine)

using是我们定义的一个自动化资源管帮助函数，它接爱两个参数化类型参数，一个是实现了AutoCloseable接口的资源类，一个是形如：T => R的函数值。func是由用户定义的对res进行操作的函数代码体，它将被传给using函数并由using代执行。而res这个资源将在using执行完成返回前调用finally代码块执行.close方法来清理打开的资源。

这个：T <: AutoCloseable范型参数限制了T类型必需为AutoCloseable类型或其子类。R范型指定using函数的返回值类型将在实际调用时被自动参数化推导出来。我们在Scala Console中参看allLine变量的类型可以看到 allLine将被正确的赋予String类型，因为我们传给using函数参数func的函数值返回类型就为String：

scala> :type allLineString

在readAll函数的定义处，有两个特别的地方：

这个函数定义在了其它函数代码体内部

它有一个@tailrec注解

在Scala中，因为函数是第一类的，它可以被赋值给一个变量。所以Scala中的def定义函数可以等价val func = (x: Int, y: Int) => x + y这个的函数字面量定义函数形式。所以，既然通过变量定义的函数可以放在其它函数代码体内，通过def定义的函数也一样可以放在其它代码体内，这和Javascript很像。

@tailrec注解的含义是这个函数是尾递归函数，编译器在编译时将对其优化成相应的while循环。若一个函数不是尾递归的，加上此注解在编译时将报错。

模式匹配（match case）

模式匹配是函数式编程里面很强大的一个特性。

之前已经见识过了模式匹配的简单使用方式，可以用它替代：if else、switch这样的分支判断。除了这些简单的功能，模式匹配还有一系列强大、易用的特性。

match 中的值、变量和类型

scala> for {
     |   x <- Seq(1, false, 2.7, "one", &#39;four, new java.util.Date(), new RuntimeException("运行时异常"))
     | } {
     |   val str = x match {
     |     case d: Double => s"double: $d"
     |     case false => "boolean false"
     |     case d: java.util.Date => s"java.util.Date: $d"
     |     case 1 => "int 1"
     |     case s: String => s"string: $s"
     |     case symbol: Symbol => s"symbol: $symbol"
     |     case unexpected => s"unexpected value: $unexpected"
     |   }
     |   println(str)
     | }
int 1
boolean false
double: 2.7
string: one
symbol: &#39;four
java.util.Date: Sun Jul 24 16:51:20 CST 2016
unexpected value: java.lang.RuntimeException: 运行时异常

上面小试牛刀校验变量类型的同时完成类型转换功能。在Java中，你肯定写过或见过如下的代码：

public void receive(message: Object) {    
if (message isInstanceOf String) {     
  String strMsg = (String) message;
        ....
    } else if (message isInstanceOf java.util.Date) {
        java.util.Date dateMsg = (java.util.Date) message;
        ....
    } ....
}

对于这样的代码，真是辣眼睛啊~~~。

序列的匹配

scala> val nonEmptySeq = Seq(1, 2, 3, 4, 5)

scala> val emptySeq = Seq.empty[Int]

scala> val emptyList = Nil

scala> val nonEmptyList = List(1, 2, 3, 4, 5)

scala> val nonEmptyVector = Vector(1, 2, 3, 4, 5)

scala> val emptyVector = Vector.empty[Int]

scala> val nonEmptyMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

scala> val emptyMap = Map.empty[String, Int]

scala> def seqToString[T](seq: Seq[T]): String = seq match {
     |   case head +: tail => s"$head +: " + seqToString(tail)
     |   case Nil => "Nil"
     | }

scala> for (seq <- Seq(
     |   nonEmptySeq, emptySeq, nonEmptyList, emptyList,
     |   nonEmptyVector, emptyVector, nonEmptyMap.toSeq, emptyMap.toSeq)) {
     |   println(seqToString(seq))
     | }
1 +: 2 +: 3 +: 4 +: 5 +: Nil
Nil
1 +: 2 +: 3 +: 4 +: 5 +: Nil
Nil
1 +: 2 +: 3 +: 4 +: 5 +: Nil
Nil
(one,1) +: (two,2) +: (three,3) +: Nil
Nil

模式匹配能很方便的抽取序列的元素，seqToString使用了模式匹配以递归的方式来将序列转换成字符串。case head +: tail将序列抽取成“头部”和“非头部剩下”两部分，head将保存序列第一个元素，tail保存序列剩下部分。而case Nil将匹配一个空序列。

case class的匹配

scala> trait Person

scala> case class Man(name: String, age: Int) extends Person

scala> case class Woman(name: String, age: Int) extends Person

scala> case class Boy(name: String, age: Int) extends Person

scala> val father = Man("父亲", 33)

scala> val mather = Woman("母亲", 30)

scala> val son = Man("儿子", 7)

scala> val daughter = Woman("女儿", 3)

scala> for (person <- Seq[Person](father, mather, son, daughter)) {
     |   person match {
     |     case Man("父亲", age) => println(s"父亲今年${age}岁")
     |     case man: Man if man.age < 10 => println(s"man is $man")
     |     case Woman(name, 30) => println(s"${name}今年有30岁")
     |     case Woman(name, age) => println(s"${name}今年有${age}岁")
     |   }
     | }
父亲今年33岁
母亲今年有30岁
man is Man(儿子,7)
女儿今年有3岁

在模式匹配中对case class进行解构操作，可以直接提取出感兴趣的字段并赋给变量。同时，模式匹配中还可以使用guard语句，给匹配判断添加一个if表达式做条件判断。

并发

Scala是对多核和并发编程的支付做得非常好，它的Future类型提供了执行异步操作的高级封装。

Future对象完成构建工作以后，控制权便会立刻返还给调用者，这时结果还不可以立刻可用。Future实例是一个句柄，它指向最终可用的结果值。不论操作成功与否，在future操作执行完成前，代码都可以继续执行而不被阻塞。Scala提供了多种方法用于处理future。

scala> :paste
// Entering paste mode (ctrl-D to finish)

import scala.concurrent.duration.Duration
import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global

val futures = (0 until 10).map { i =>
  Future {
    val s = i.toString
    print(s)
    s
  }
}

val future = Future.reduce(futures)((x, y) => x + y)

val result = Await.result(future, Duration.Inf)

// Exiting paste mode, now interpreting.

0132564789

scala> val result = Await.result(future, Duration.Inf)
result: String = 0123456789

上面代码创建了10个Future对象，Future.apply方法有两个参数列表。第一个参数列表包含一个需要并发执行的命名方法体（by-name body）；而第二个参数列表包含了隐式的ExecutionContext对象，可以简单的把它看作一个线程池对象，它决定了这个任务将在哪个异步（线程）执行器中执行。futures对象的类型为IndexedSeq[Future[String]]。本示例中使用Future.reduce把一个futures的IndexedSeq[Future[String]]类型压缩成单独的Future[String]类型对象。Await.result用来阻塞代码并获取结果，输入的Duration.Inf用于设置超时时间，这里是无限制。

这里可以看到，在Future代码内部的println语句打印输出是无序的，但最终获取的result结果却是有序的。这是因为虽然每个Future都是在线程中无序执行，但Future.reduce方法将按传入的序列顺序合并结果。

除了使用Await.result阻塞代码获取结果，我们还可以使用事件回调的方式异步获取结果。Future对象提供了几个方法通过回调将执行的结果返还给调用者，常用的有：

onComplete: PartialFunction[Try[T], Unit]：当任务执行完成后调用，无论成功还是失败

onSuccess: PartialFunction[T, Unit]：当任务成功执行完成后调用

onFailure: PartialFunction[Throwable, Unit]：当任务执行失败（异常）时调用

import scala.concurrent.Future
import scala.util.{Failure, Success}
import scala.concurrent.ExecutionContext.Implicits.global

val futures = (1 to 2) map {
  case 1 => Future.successful("1是奇数")
  case 2 => Future.failed(new RuntimeException("2不是奇数"))
}

futures.foreach(_.onComplete {
  case Success(i) => println(i)
  case Failure(t) => println(t)
})

Thread.sleep(2000)

futures.onComplete方法是一个偏函数，它的参数是：Try[String]。Try有两个子类，成功是返回Success[String]，失败时返回Failure[Throwable]，可以通过模式匹配的方式获取这个结果。

总结

本篇文章简单的介绍了Scala的语言特性，本文并不只限于Java程序员，任何有编程经验的程序员都可以看。现在你应该对Scala有了一个基础的认识，并可以写一些简单的代码了。