重剑无锋--小谈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-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倾向于使用不变量，开销上要大一些（有很多优化策略，这个我们后面有时间在说吧）。