本来调研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-inlined val b = bf(repr) b.sizeHint(this) b } val b = builder for (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).size val bs: IndexedSeq[Builder[B, CC[B]]] = IndexedSeq.fill(headSize)(genericBuilder[B]) for (xs <- sequential) { var i = 0 for (x <- asTraversable(xs).seq) { if (i >= headSize) fail bs(i) += x i += 1 } if (i != headSize) fail } val bb = genericBuilder[CC[B]] for (b <- bs) bb += b.result bb.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 = true b append start for (x <- self) { if (first) { b append x first = false } else { b append sep b append x } } b append end b } def mkString(start: String, sep: String, end: String): String = addString(new StringBuilder(), start, sep, end).toString def mkString(sep: String): String = mkString("", sep, "") def mkString: String = mkString("")
mkString是非常高频使用的代码。
总结一下,Scala代码简洁而强大有两个根本原因 一是编译器的类型推导非常强大,而是无处不在的隐式转换极大的简化了不必要的代码。
另,所谓“重剑”有两层含义一是指威力巨大,实现同样功能的Scala代码一般只有Java代码的1/2到1/10,另一层由于Scala倾向于使用不变量,开销上要大一些(有很多优化策略,这个我们后面有时间在说吧)。