挑逗Java程序员的那些Scala绝技

有个问题一直困扰着 Scala 社区，为何一些 Java 开发者将 Scala 捧到了天上，认为它是来自上帝之吻的完美语言；而另一些 Java 开发者却对它望而却步，认为它过于复杂而难以理解。一样是 Java 开发者，为什么会出现两种大相径庭的态度，我想这其中必定有误会。Scala 是一粒金子，可是被一些表面上看起来很是复杂的概念或语法包裹的太严实，以致于人们很难在短期内搞清楚它的价值。与此同时，Java 也在不断地摸索前进，可是因为 Java 背负了沉重的历史包袱，因此每向前一步都显得异常艰难。本文主要面向 Java 开发人员，但愿从解决 Java 中实际存在的问题出发，梳理最容易吸引 Java 开发者的一些 Scala 特性。但愿能够帮助你们快速找到那些真正能够打动你的点。

一、类型推断

挑逗指数: 四星

咱们知道，Scala 一贯以强大的类型推断闻名于世。不少时候，咱们无须关心 Scala 类型推断系统的存在，由于不少时候它推断的结果跟直觉是一致的。 Java 在 2016 年也新增了一份提议JEP 286，计划为 Java 10 引入局部变量类型推断(Local-Variable Type Inference)。利用这个特性，咱们可使用 var 定义变量而无需显式声明其类型。不少人认为这是一项激动人心的特性，可是高兴以前咱们要先看看它会为咱们带来哪些问题。

与 Java 7 的钻石操做符冲突

Java 7 引进了钻石操做符，使得咱们能够下降表达式右侧的冗余类型信息，例如：

List<Integer> numbers = new ArrayList<>();

若是引入了 var，则会致使左侧的类型丢失，从而致使整个表达式的类型丢失：

var numbers = new ArrayList<>();

因此 var 和 钻石操做符必须二选一，鱼与熊掌不可兼得。

容易致使错误的代码

下面是一段检查用户是否存在的 Java 代码：

public boolean userExistsIn(Set<Long> userIds) {
    var userId = getCurrentUserId();
    return userIds.contains(userId);
}

请仔细观察上述代码，你能一眼看出问题所在吗？ userId 的类型被 var 隐去了，若是 getCurrentUserId() 返回的是 String 类型，上述代码仍然能够正常经过编译，却无形中埋下了隐患，这个方法将会永远返回 false， 由于 Set<Long>.contains 方法接受的参数类型是 Object。可能有人会说，就算显式声明了类型，不也是于事无补吗？

public boolean userExistsIn(Set<Long> userIds) {
    String userId = getCurrentUserId();
    return userIds.contains(userId);
}

Java 的优点在于它的类型可读性，若是显式声明了 userId 的类型，虽然仍是能够正常经过编译，可是在代码审查时，这个错误将会更容易被发现。 这种类型的错误在 Java 中很是容易发生，由于 getCurrentUserId() 方法极可能由于重构而改变了返回类型，而 Java 编译器却在关键时刻背叛了你，没有报告任何的编译错误。 虽然这是因为 Java 的历史缘由致使的，可是因为 var 的引入，会致使这个错误不断的蔓延。

很显然，在 Scala 中，这种低级错误是没法逃过编译器法眼的：

def userExistsIn(userIds: Set[Long]): Boolean = {
    val userId = getCurrentUserId()
    userIds.contains(userId)
}

若是 userId 不是 Long 类型，则上面的程序没法经过编译。

二、字符串加强

挑逗指数: 四星

经常使用操做

Scala 针对字符做进行了加强，提供了更多的使用操做：

//字符串去重
"aabbcc".distinct // "abc"

//取前n个字符，若是n大于字符串长度返回原字符串
"abcd".take(10) // "abcd"

//字符串排序
"bcad".sorted // "abcd"

//过滤特定字符
"bcad".filter(_ != 'a') // "bcd"

//类型转换
"true".toBoolean
"123".toInt
"123.0".toDouble

其实你彻底能够把 String 当作 Seq[Char] 使用，利用 Scala 强大的集合操做，你能够为所欲为地操做字符串。

原生字符串

在 Scala 中，咱们能够直接书写原生字符串而不用进行转义，将字符串内容放入一对三引号内便可：

//包含换行的字符串
val s1= """Welcome here.
   Type "HELP" for help!"""
   
//包含正则表达式的字符串   
val regex = """\d+"""

字符串插值

经过 s 表达式，咱们能够很方便地在字符串内插值：

val name = "world"
val msg = s"hello, ${name}" // hello, world

三、集合操做

挑逗指数: 五星

Scala 的集合设计是最容易让人着迷的地方，就像毒品同样，一沾上便让人深陷其中难以自拔。经过 Scala 提供的集合操做，咱们基本上能够实现 SQL 的所有功能，这也是为何 Scala 可以在大数据领域独领风骚的重要缘由之一。

简洁的初始化方式

在 Scala 中，咱们能够这样初始化一个列表：

val list1 = List(1, 2, 3)

能够这样初始化一个 Map：

val map = Map("a" -> 1, "b" -> 2)

全部的集合类型都可以用相似的方式完成初始化，简洁而富有表达力。

便捷的 Tuple 类型

有时方法的返回值可能不止一个，Scala 提供了 Tuple (元组)类型用于临时存放多个不一样类型的值，同时可以保证类型安全性。千万不要认为使用 Java 的 Array 类型也能够一样实现 Tuple 类型的功能，它们之间有着本质的区别。Tuple 会显式声明全部元素的各自类型，而不是像 Java Array 那样，元素类型会被向上转型为全部元素的父类型。
咱们能够这样初始化一个 Tuple:

val t = ("abc", 123, true)
val s: String  = t._1 // 取第1个元素
val i: Int     = t._2 // 取第2个元素
val b: Boolean = t._3 // 取第3个元素

须要注意的是 Tuple 的元素索引从1开始。

下面的示例代码是在一个长整型列表中寻找最大值，并返回这个最大值以及它所在的位置：

def max(list: List[Long]): (Long, Int) = list.zipWithIndex.sorted.reverse.head

咱们经过 zipWithIndex 方法获取每一个元素的索引号，从而将 List[Long] 转换成了 List[(Long, Int)]，而后对其依次进行排序、倒序和取首元素，最终返回最大值及其所在位置。

四、链式调用

经过链式调用，咱们能够将关注点放在数据的处理和转换上，而无需考虑如何存储和传递数据，同时也避免了建立大量无心义的中间变量，大大加强程序的可读性。其实上面的 max 函数已经演示了链式调用。下面这段代码演示了若是在一个整型列表中寻找大于3的最小奇数：

val list = List(3, 6, 4, 1, 7, 8)
list.filter(i => i % 2 == 1).filter(i => i > 3).sorted.head

五、非典型集合操做

Scala 的集合操做很是丰富，若是要详细说明足够写一本书了。这里仅列出一些不那么经常使用但却很是好用的操做。

去重：

List(1, 2, 2, 3).distinct // List(1, 2, 3)

交集：

Set(1, 2) & Set(2, 3)   // Set(2)

并集：

Set(1, 2) | Set(2, 3) // Set(1, 2, 3)

差集：

Set(1, 2) &~ Set(2, 3) // Set(1)

排列：

List(1, 2, 3).permutations.toList
//List(List(1, 2, 3), List(1, 3, 2), List(2, 1, 3), List(2, 3, 1), List(3, 1, 2), List(3, 2, 1))

组合：

List(1, 2, 3).combinations(2).toList 
// List(List(1, 2), List(1, 3), List(2, 3))

六、并行集合

Scala 的并行集合能够利用多核优点加速计算过程，经过集合上的 par 方法，咱们能够将原集合转换成并行集合。并行集合利用分治算法将计算任务分解成不少子任务，而后交给不一样的线程执行，最后将计算结果进行汇总。下面是一个简单的示例：

(1 to 10000).par.filter(i => i % 2 == 1).sum

七、优雅的值对象

挑逗指数: 五星

Case Class

Scala 标准库包含了一个特殊的 Class 叫作 Case Class，专门用于领域层值对象的建模。它的好处是全部的默认行为都通过了合理的设计，开箱即用。下面咱们使用 Case Class 定义了一个 User 值对象：

case class User(name: String, role: String = "user", addTime: Instant = Instant.now())

仅仅一行代码便完成了 User 类的定义，请脑补一下 Java 的实现。

简洁的实例化方式

咱们为 role 和 addTime 两个属性定义了默认值，因此咱们能够只使用 name 建立一个 User 实例：

val u = User("jack")

在建立实例时，咱们也能够命名参数(named parameter)语法改变默认值：

val u = User("jack", role = "admin")

在实际开发中，一个模型类或值对象可能拥有不少属性，其实不少属性均可以设置一个合理的默认值。利用默认值和命名参数，咱们能够很是方便地建立模型类和值对象的实例。 因此在 Scala 中基本上不须要使用工厂模式或构造器模式建立对象，若是对象的建立过程确实很是复杂，则能够放在伴生对象中建立，例如:

object User {
  def apply(name: String): User = User(name, "user", Instant.now())
}

在使用伴生对象方法建立实例时能够省略方法名 apply，例如：

User("jack") // 等价于 User.apply("jack")

在这个例子里，使用伴生对象方法实例化对象的代码，与上面使用类构造器的代码彻底同样，编译器会优先选择伴生对象的 apply 方法。

不可变性

Case Class 在默认状况下实例是不可变的，意味着它能够被任意共享，并发访问时也无需同步，大大地节省了宝贵的内存空间。而在 Java 中，对象被共享时须要进行深拷贝，不然一个地方的修改会影响到其它地方。例如在 Java 中定义了一个 Role 对象：

public class Role {
    public String id = "";
    public String name = "user";
    
    public Role(String id, String name) {
        this.id = id;
        this.name = name;
    }
}

若是在两个 User 之间共享 Role 实例就会出现问题，就像下面这样：

u1.role = new Role("user", "user");
u2.role = u1.role;

当咱们修改 u1.role 时，u2 就会受到影响，Java 的解决方式是要么基于 u1.role 深度克隆一个新对象出来，要么新建立一个 Role 对象赋值给 u2。

对象拷贝

在 Scala 中，既然 Case Class 是不可变的，那么若是想改变它的值该怎么办呢？其实很简单，利用命名参数能够很容易拷贝一个新的不可变对象出来：

val u1 = User("jack")
val u2 = u1.copy(name = "role", role = "admin")

七、清晰的调试信息

咱们不须要编写额外的代码即可以获得清晰的调试信息，例如：

val users = List(User("jack"), User("rose"))
println(users)

输出内容以下：

List(User(jack,user,2018-10-20T13:03:16.170Z), User(rose,user,2018-10-20T13:03:16.170Z))

默认使用值比较相等性

在 Scala 中，默认采用值比较而非引用比较，使用起来更加符合直觉：

User("jack") == User("jack") // true

上面的值比较是开箱即用的，无需重写 hashCode 和 equals 方法。

八、模式匹配

挑逗指数: 五星

更强的可读性

当你的代码中存在多个 if 分支而且 if 之间还会有嵌套，那么代码的可读性将会大大下降。而在 Scala 中使用模式匹配能够很容易地解决这个问题，下面的代码演示货币类型的匹配：

sealed trait Currency
case class Dollar(value: Double) extends Currency
case class Euro(value: Double) extends Currency
val Currency = ...
currency match {
    case Dollar(v) => "$" + v
    case Euro(v) => "€" + v
    case _ => "unknown"
}

咱们也能够进行一些复杂的匹配，而且在匹配时能够增长 if 判断：

use match {
    case User("jack", _, _) => ...
    case User(_, _, addTime) if addTime.isAfter(time) => ...
    case _ => ...
}

变量赋值

利用模式匹配，咱们能够快速提取特定部分的值并完成变量定义。 咱们能够将 Tuple 中的值直接赋值给变量：

val tuple = ("jack", "user", Instant.now())
val (name, role, addTime) = tuple
// 变量 name, role, addTime 在当前做用域内能够直接使用

对于 Case Class 也是同样：

val User(name, role, addTime) = User("jack")
// 变量 name, role, addTime 在当前做用域内能够直接使用

九、并发编程

挑逗指数: 五星

在 Scala 中，咱们在编写并发代码时只须要关心业务逻辑便可，而不须要关注任务如何执行。咱们能够经过显式或隐式方式传入一个线程池，具体的执行过程由线程池完成。Future 用于启动一个异步任务而且保存执行结果，咱们能够用 for 表达式收集多个 Future 的执行结果，从而避免回调地狱：

val f1 = Future{ 1 + 2 }
val f2 = Future{ 3 + 4 }
for {
    v1 <- f1
    v2 <- f2
}{
    println(v1 + v2) // 10
}

使用 Future 开发爬虫程序将会让你事半功倍，假如你想同时抓取 100 个页面数据，一行代码就能够了：

Future.sequence(urls.map(url => http.get(url))).foreach{ contents => ...}

Future.sequence 方法用于收集全部 Future 的执行结果，经过 foreach 方法咱们能够取出收集结果并进行后续处理。

当咱们要实现彻底异步的请求限流时，就须要精细地控制每一个 Future 的执行时机。也就是说咱们须要一个控制Future的开关，没错，这个开关就是Promise。每一个Promise实例都会有一个惟一的Future与之相关联：

val p = Promise[Int]()
val f = p.future
for (v <- f) { println(v) } // 3秒后才会执行打印操做

//3秒钟以后返回3
Thread.sleep(3000)
p.success(3)

十、跨线程错误处理

Java 经过异常机制处理错误，可是问题在于 Java 代码只能捕获当前线程的异常，而没法跨线程捕获异常。而在 Scala 中，咱们能够经过 Future 捕获任意线程中发生的异常。
异步任务可能成功也可能失败，因此咱们须要一种既能够表示成功，也能够表示失败的数据类型，在 Scala 中它就是 Try[T]。Try[T] 有两个子类型，Success[T]表示成功，Failure[T]表示失败。就像量子物理学中薛定谔的猫，在异步任务执行以前，你根本没法预知返回的结果是 Success[T] 仍是 Failure[T]，只有当异步任务完成执行之后结果才能肯定下来。

val f = Future{ /*异步任务*/ } 

// 当异步任务执行完成时
f.value.get match {
  case Success(v) => // 处理成功状况
  case Failure(t) => // 处理失败状况
}

咱们也可让一个 Future 从错误中恢复：

val f = Future{ /*异步任务*/ }
for{
  result <- f.recover{ case t => /*处理错误*/ }
} yield {
  // 处理结果
}

十一、声明式编程

挑逗指数: 四星

Scala 鼓励声明式编程，采用声明式编写的代码可读性更强。与传统的过程式编程相比，声明式编程更关注我想作什么而不是怎么去作。例如咱们常常要实现分页操做，每页返回 10 条数据：

val allUsers = List(User("jack"), User("rose"))
val pageList = 
  allUsers
    .sortBy(u => (u.role, u.name, u.addTime)) // 依次按 role, name, addTime 进行排序
    .drop(page * 10) // 跳过以前页数据
    .take(10) // 取当前页数据，如不足10个则所有返回

你只须要告诉 Scala 要作什么，好比说先按 role 排序，若是 role 相同则按 name 排序，若是 role 和 name 都相同，再按 addTime 排序。底层具体的排序实现已经封装好了，开发者无需实现。

十二、面向表达式编程

挑逗指数: 四星

在 Scala 中，一切都是表达式，包括 if, for, while 等常见的控制结构均是表达式。表达式和语句的不一样之处在于每一个表达式都有明确的返回值。

val i = if(true){ 1 } else { 0 } // i = 1
val list1 = List(1, 2, 3)
val list2 = for(i <- list1) yield { i + 1 }

不一样的表达式能够组合在一块儿造成一个更大的表达式，再结合上模式匹配将会发挥巨大的威力。下面咱们以一个计算加法的解释器来作说明。

一个整数加法解释器

咱们首先定义基本的表达式类型：

abstract class Expr
case class Number(num: Int) extends Expr
case class PlusExpr(left: Expr, right: Expr) extends Expr

上面定义了两个表达式类型，Number 表示一个整数表达式， PlusExpr 表示一个加法表达式。
下面咱们基于模式匹配实现表达式的求值运算：

def evalExpr(expr: Expr): Int = {
  expr match {
    case Number(n) => n
    case PlusExpr(left, right) => evalExpr(left) + evalExpr(right)
  }
}

咱们来尝试针对一个较大的表达式进行求值：

evalExpr(PlusExpr(PlusExpr(Number(1), Number(2)), PlusExpr(Number(3), Number(4)))) // 10

1三、隐式参数和隐式转换

挑逗指数: 五星

隐式参数

若是每当要执行异步任务时，都须要显式传入线程池参数，你会不会以为很烦？Scala 经过隐式参数为你解除这个烦恼。例如 Future 在建立异步任务时就声明了一个 ExecutionContext 类型的隐式参数，编译器会自动在当前做用域内寻找合适的 ExecutionContext，若是找不到则会报编译错误：

implicit val ec: ExecutionContext = ???
val f = Future { /*异步任务*/ }

固然咱们也能够显式传递 ExecutionContext 参数，明确指定使用的线程池：

implicit val ec: ExecutionContext = ???
val f = Future { /*异步任务*/ }(ec)

隐式转换

隐式转换相比较于隐式参数，使用起来更来灵活。若是 Scala 在编译时发现了错误，在报错以前，会先对错误代码应用隐式转换规则，若是在应用规则以后可使得其经过编译，则表示成功地完成了一次隐式转换。

在不一样的库间实现无缝对接

当传入的参数类型和目标类型不匹配时，编译器会尝试隐式转换。利用这个功能，咱们将已有的数据类型无缝对接到三方库上。例如咱们想在 Scala 项目中使用 MongoDB 的官方 Java 驱动执行数据库查询操做，可是查询接口接受的参数类型是 BsonDocument，因为使用 BsonDocument 构建查询比较笨拙，咱们但愿可以使用 Scala 的 JSON 库构建一个查询对象，而后直接传递给官方驱动的查询接口，而无需改变官方驱动的任何代码，利用隐式转换能够很是轻松地实现这个功能：

implicit def toBson(json: JsObject): BsonDocument =  ...

val json: JsObject = Json.obj("_id" -> "0")
jCollection.find(json) // 编译器会自动调用 toBson(json)

利用隐式转换，咱们能够在不改动三方库代码的状况下，将咱们的数据类型与其进行无缝对接。例如咱们经过实现一个隐式转换，将 Scala 的 JsObject 类型无缝地对接到了 MongoDB 的官方 Java 驱动的查询接口中，看起就像是 MongoDB 官方驱动真的提供了这个接口同样。

同时咱们也能够未来自三方库的数据类型无缝集成到现有的接口中，也只须要实现一个隐式转换方法便可。

扩展已有类的功能

例如咱们定义了一个美圆货币类型 Dollar:

class Dollar(value: Double) {
  def + (that: Dollar): Dollar = ...
  def + (that: Int): Dollar = ...
}

因而咱们能够执行以下操做：

val halfDollar = new Dollar(0.5)
halfDollar + halfDollar // 1 dollar
halfDollar + 0.5 // 1 dollar

可是咱们却没法执行像 0.5 + halfDollar 这样的运算，由于在 Double 类型上没法找到一个合适的 + 方法。

在 Scala 中，为了实现上面的运算，咱们只须要实现一个简单的隐式转换就能够了：

implicit def doubleToDollar(d: Double) = new Dollar(d)

0.5 + halfDollar // 等价于 doubleToDollar(0.5) + halfDollar

更好的运行时性能

在平常开发中，咱们一般须要将值对象转换成 Json 格式以方便数据传输。Java 的一般作法是使用反射，可是咱们知道使用反射是要付出代价的，要承受运行时的性能开销。而 Scala 则能够在编译时为值对象生成隐式的 Json 编解码器，这些编解码器只不过是普通的函数调用而已，不涉及任何反射操做，在很大程度上提高了系统的运行时性能。

小结

若是你坚持读到了这里，我会以为很是欣慰，很大可能上 Scala 的某些特性已经吸引了你。可是 Scala 的魅力远不止如此，以上列举的仅仅是一些最容易抓住你眼球的一些特性。若是你愿意推开 Scala 这扇大门，你将会看到一个彻底不同的编程世界。本文欢迎转载，请注明做者沐风(joymufeng)。

Refer:

[1] 3小时Scala入门

http://bit.ly/2IXupMY

[2] 大数据分析工程师入门2--Scala基础

https://mp.weixin.qq.com/s/VIUlROU2hhz7oeOFTVC5sA