重剑无锋--小谈Scala编程

本文主要是介绍重剑无锋--小谈Scala编程，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

本来调研Akka这个并发框架，不知不觉迷上了Scala编程已有一段时间。期间拜读Scala各种书籍，发现在国内实在太小众，Scala融合了面向对象及函数式的特点，有着强大的类型系统。外在来看Scala代码非常简洁并且有不输于动态语言的强大表现力，本文下面通过一个例子谈一谈。

要实现这么一个小功能：
将任意int型转换为如下LED形式的字符串（三行）

  '     _  _  _  _  _     _  _     _'    |_||_|  ||_ |_ |_| _| _|  || |'     _||_|  ||_| _|  | _||_   ||_|

先来一段中规中矩的Java代码，用二维数组存储0-9的三行写法。

public class ScalaExample {public static void main(String[] args){System.out.println(num2led(1234));}private static Map<String, String[]> nums;static {nums = new HashMap<>();String[][] arrays = {{" _ ", "| |", "|_|"},{"   ", "  |", "  |"},{" _ ", " _|", "|_ "},{" _ ", " _|", " _|"},{"   ", "|_|", "  |"},{" _ ", "|_ ", " _|"},{" _ ", "|_ ", "|_|"},{" _ ", "  |", "  |"},{" _ ", "|_|", "|_|"},{" _ ", "|_|", " _|"}};for(int i = 0;i<arrays.length;i++){nums.put(String.valueOf(i), arrays[i]);}}public static String num2led(int num ){ArrayList<String[]> result = new ArrayList<String[]>();for (char c : String.valueOf(num).toCharArray()){result.add(nums.get(String.valueOf(c)));}StringBuffer sb = new StringBuffer();for(int i=0; i<3; i++ ){for(int j=0; j<result.size(); j++){sb.append(result.get(j)[i]);}sb.append("\n");}return sb.substring(0, sb.length()-1).toString();}
}

Scala代码(为简便在终端窗口中运行)

val nums = Map('0' -> List(" _ ", "| |", "|_|"),'1' -> List("   ", "  |", "  |"),'2' -> List(" _ ", " _|", "|_ "),'3' -> List(" _ ", " _|", " _|"),'4' -> List("   ", "|_|", "  |"),'5' -> List(" _ ", "|_ ", " _|"),'6' -> List(" _ ", "|_ ", "|_|"),'7' -> List(" _ ", "  |", "  |"),'8' -> List(" _ ", "|_|", "|_|"),'9' -> List(" _ ", "|_|", " _|"))def num2led(num: Int) = num.toString().map(nums).transpose.map(_.mkString).mkString("\n")println(num2led(123)

scala构建数据内容相同，执行代码只有一行。考虑到很多朋友不熟悉Scala，分析一下这唯一一句代码。

def num2led(num: Int) = num.toString().map(nums).transpose.map(_.mkString).mkString("\n")

1）num.toString().map(nums)
toString()顾名思义将输入变为字符串，下面是该程序中最神奇的地方，Scala中字符串默认为字符的序列，而通过强大的隐式转换（后面还会讲），自动将字符串拆分成字符，并匹配nums 这个Map对象。
map是函数式语言中的高阶方法，本身具有构建序列的能力，于是得到下面的结果。

------------------------------------------------------------------------------------

Vector(List( , |, |), List( _ , _|, |_ ), List( _ , _|, _|))

------------------------------------------------------------------------------------

2）num.toString().map(nums).transpose

transpose这个方法有翻转矩阵的能力，也就是说将原来的行变成列，以便后面使用。
翻转后的样子：注意List 变成了Vector，这个是自动类型推断出来的。

------------------------------------------------------------------------------------
Vector(Vector( , _ , _ ), Vector( |, _|, _|), Vector( |, |_ , _|))

------------------------------------------------------------------------------------
3）num.toString().map(nums).transpose.map(_.mkString)
又是一个map方法，这个相对来说比较常见，传入一个函数，map负责迭代内部序列并构建新序列。
------------------------------------------------------------------------------------
Vector( _ _ , | _| _|, ||_ _|)

------------------------------------------------------------------------------------

5）num.toString().map(nums).transpose.map(_.mkString).mkString("\n")
最后mkString是序列自带的方法，将内部元素用“”拼接起来。
_ _
| _| _|
||_ _|

非常简练是不是，下面我们用 javap 命令看下这些代码的背后都是如何实现的。

1）num.toString().map(nums)
Scala编译器会将代码做很多加工，这里面 Predef类的fallbackStringCanBuildFrom()方法，和
scala包对象Predef（改对象与会在每个Scala程序中自动import，类似于java的java.lang）

  implicit def fallbackStringCanBuildFrom[T]: CanBuildFrom[String, T, immutable.IndexedSeq[T]] =new CanBuildFrom[String, T, immutable.IndexedSeq[T]] {def apply(from: String) = immutable.IndexedSeq.newBuilder[T]def apply() = immutable.IndexedSeq.newBuilder[T]}

这个map的参数是一个Map对象，而后面那个map方法参数为 mkString 方法，感觉似乎两个map 的参数完全不同，但是调用的代码却都是上面这段代码！奥秘就在于参数实际类型是CanBuildFrom对象，Scala中方法实际也是对象的一种!

scala.collection包中特质TraversableLike 的通用方法

def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {def builder = { // extracted to keep method size under 35 bytes, so that it can be JIT-inlinedval b = bf(repr)b.sizeHint(this)b}val b = builderfor (x <- this) b += f(x)b.result}

2）num.toString().map(nums).transpose
位于scala/collection/generic/GenericTraversableTemplate包中：

 @migration("`transpose` throws an `IllegalArgumentException` if collections are not uniformly sized.", "2.9.0")def transpose[B](implicit asTraversable: A => /*<:<!!!*/ GenTraversableOnce[B]): CC[CC[B] @uncheckedVariance] = {if (isEmpty)return genericBuilder[CC[B]].result()def fail = throw new IllegalArgumentException("transpose requires all collections have the same size")val headSize = asTraversable(head).sizeval bs: IndexedSeq[Builder[B, CC[B]]] = IndexedSeq.fill(headSize)(genericBuilder[B])for (xs <- sequential) {var i = 0for (x <- asTraversable(xs).seq) {if (i >= headSize) failbs(i) += xi += 1}if (i != headSize)fail}val bb = genericBuilder[CC[B]]for (b <- bs) bb += b.resultbb.result()}def genericBuilder[B]: Builder[B, CC[B]] = companion.newBuilder[B]

GenericXXX类是Scala集合框架中的共通部件，同时提供给一般集合和并行集合。代码较为抽象，不做太深入的解读，大家可以看到使用了很多 Builder，Builder构建器是Scala标准库中非常常见的，因为函数式的方法几乎全都具有生成新的序列或其他对象的能力。

3）num.toString().map(nums).transpose.map(_.mkString)
4）num.toString().map(nums).transpose.map(_.mkString).mkString("\n")
这两步都调用了 mkString方法，前者不带参数且本身作为map的参数（函数是头等对象），后者有作为分割符的参数。

scala/collection包 TraversableOnce对象

  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = {var first = trueb append startfor (x <- self) {if (first) {b append xfirst = false}else {b append sepb append x}}b append endb}def mkString(start: String, sep: String, end: String): String =addString(new StringBuilder(), start, sep, end).toStringdef mkString(sep: String): String = mkString("", sep, "")def mkString: String = mkString("")

mkString是非常高频使用的代码。

总结一下，Scala代码简洁而强大有两个根本原因一是编译器的类型推导非常强大，而是无处不在的隐式转换极大的简化了不必要的代码。

另，所谓“重剑”有两层含义一是指威力巨大，实现同样功能的Scala代码一般只有Java代码的1/2到1/10，另一层由于Scala倾向于使用不变量，开销上要大一些（有很多优化策略，这个我们后面有时间在说吧）。

这篇关于重剑无锋--小谈Scala编程的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！