Scala

println("Hello Scala") [email_address] Jul 12, 2011

一、什么是 scala 二、谁在用 scala 三、为什么要用 scala 四、快速入门五、加点难度六、更进一步

什么是 scala http://www.scala-lang.org/ scala 是 Scalable Language 的简写，由 Martin Odersky (Generic Java 的作者 ) 发明，目的就是创造一个 jvm 上的高度可扩展的语言。 2003 诞生，前身是 Pizza （ 1996 ，晚 java 一年）、 Funnel ，最新版本是 2.9.0.1 ，它具有以下特性： 1.It has an event-based concurrency model. （基于事件的并行模式） 2.It supports both an imperative style and a functional style. （支持命令式和函数式编程） 3.It is purely object-oriented. （纯粹的面向对象） 4.It intermixes well with Java. （和 java 的完美混合） 5.It enforces sensible static typing. （强制静态） 6.It is concise and expressive. （简洁且易于表达的） 7.It is built on a small kernel. （只有一个很小的核心） 8.It is highly scalable, and it takes less code to create high-performing applications. （易于扩展，只用很少的代码即可写出高性能的程序。 type less ， do more ）

什么是 scala 之 FP Functional Programming 函数式编程 , 和命令式编程相比，函数式编程强调函数的计算比指令的执行重要。和过程化编程相比，函数式编程里，函数的计算可随时调用。函数式编程常被认为严重耗费在 CPU 和存储器资源 1. 函数是头等公民（ class 、 object 、 xml ），正如 int 之类的，你可以将函数当做参数来传递或返回，即高阶函数；也可以在函数中定义函数，可以定义匿名函数。 2. 不可变数据结构，也就是说程序的操作是对数值的映射修改而不是改数据，同时任何方法都不容许出现副作用，它们只通过参数和返回值与环境进行交互，应该是引用透明的）函数编程语言最重要的基础是 λ 演算（又被称为最小的通用程序设计语言），它包括一条变换规则（变量替换）和一条函数定义方式，这种演算可以用来清晰地定义什么是一个可计算函数函数式编程一般会采用递归而不是循环，纯函数编程不含有变量和副作用，所以在并行运算中将有很大的发挥空间，最早的是 Lisp （现在是一个家族），后来有 Haskell 、 Clean 、 Erlang 、 ML （也是一个家族，如 Ocaml ）、 F# （基于 Ocaml ）和 Miranda 等。

谁在用 scala Twitter LinkedIn Novell FourSquare Sony Siemens yammer vmware opower typesafe qiyi （ baidu ） ...

为什么要用 scala scala 混合了 FP 和 OOP ，基于 actor 的事件传导式多线程编程，完全基于 java ，可以利用所有 java 已有的东西，静态且强类型，超实用的 api ，重载操作符，基于 trait 的多重继承的混入机制， xml 、闭包、模式匹配等的语言级别支持，可以直接用来写脚本，写属于你的 DSL ，比 jvm 上第二大的语言 groovy 有着更高的性能，更易调试，语法更简洁而优雅，相对来讲有着高发展速度（ Eric Raymond 的教堂集市学）你可以在任何使用 java 的地方来使用 scala ，所有的，包括 android ， .net 等。可以写出很好的并行程序，也可以写出属于自己的 DSL http://www.assembla.com/wiki/show/scala-ide/Developing_for_Android 少打好多字，比 groovy 还少， type less ， do more Akka 、 lift PS ：这是一群聪明人写的聪明语言，但是细节做得很差

为什么要用 scala 举几个例子：留个作业：等分享完了再看一下这块例子的代码快排 def qs(aa:Array[Int]):Array[Int]={ if(aa.length<=1)aa else { val pivot=aa(aa.length/2) Array.concat( qs(aa.filter(pivot>)), aa.filter(pivot==), qs(aa.filter(pivot<)) ) } } 多个变量快速赋值 val (a,b,c)=(List(1,3),8, "fds" ) 会得到 a: List[Int] = List(1, 3) b: Int = 8 c: java.lang.String = fds val a,b,c=0 会得到 a: Int = 0 b: Int = 0 c: Int = 0

为什么要用 scala 举几个例子：一个 List[String] 中是否有大写字母 xs.exists(_.exists(_.isUpperCase)) 统计一个全数字文件的总和 import scala.io.Source val lines=Source.fromFile( "d:/1.txt" ).getLines (0 /: lines)(_.toInt + _.toInt) 解析 xml import scala.xml.XML val xml=XML.loadFile("therm1.xml") 定义一个得瑟留言类 class Comment(username:String,content:String,times:Int){ require(times> 0) def this (username:String)= this (username, " 书记万税 " ,10) override def toString = username+ " 喊了 " +times+ " 遍： " +content }

为什么要用 scala 举几个例子：投连险有这么一段代码 private static String[] supportEnvs = new String[] { "dev", "dly", "prd", "tst", "pre", "perf" }; ... for (String s : supportEnvs) { if (s.equals(_envName)) { envName = _envName; break; } } 很麻烦，不是么，那么放到 scala 里 def supportEnvs =List( "dev" , "dly" , "prd" , "tst" , "pre" , "perf" ) if (supportEnvs contains _envName) envName = _envName

为什么要用 scala 举几个例子： class MyClass( var index: Int, var name: String) 看看生成的代码 import scala.ScalaObject; import scala.reflect.ScalaSignature; @ScalaSignature(bytes= " 略 ..." ) public class MyClass implements ScalaObject{ private int index; private String name; public int index(){ return this .index; } public void index_$eq(int paramInt) { this .index = paramInt; } public String name() { return this.name; } public void name_$eq(String paramString) { this .name = paramString; } public MyClass(int index, String name) { } }

快速入门 val 和 var （类型推断）不过 var a=null 和 java 不一样，不能再次赋值，因为这时已经被附成了 Null 类（强类型） def Unit ，可认为是 void ，但不同 Type less ,do more 省略 ; 省略 return ：但，递归函数必须显示声明返回类型省略 . 省略括号：注意的是 println 和 groovy 的不同脚本语言？ Ok ，可以当成脚本语言去写然后用 scala xx.scala 执行脚本数不存在 ++ ， -- ，但可以自己定义任何东西都有返回值

快速入门数组 Array 不是用 [] 而是用 () 一个数组 Array[String] strs, 则 strs(1) 实际上是 strs.apply(1) strs(1)= "fsda" 实际上是 strs.update(1, "fsda" ) val numNames = Array( "zero" , "one" , "two" ) 实际上仍然是 Array.apply("zero", "one", "two") ，但这里调用的是 Array 的伴随类的 apply fill 、 tabulate 、 range （采用的是 until 策略） if 和 java 一样，必须是 boolean 而不像 groovy 那样不会强求你是否处理异常，但因为有个异常强大的模式匹配，异常处理也变得很华丽 catch { case ex: FileNotFoundException => // Handle missing file case ex: IOException => // Handle other I/O error }

快速入门更加简化的 foreach 举个例子，循环一个数组并打印， java 传统写法 for (int i:args) { System.out.println(i); } 在 scala 中 args.foreach(arg => println(arg)) 再简化 args.foreach(println(_)) 再简化 args.foreach(println) 再简化 args foreach println java:38 个字， scala ： 18 个字

快速入门函数文法 : 形如 (x: Int, y: Int) => x + y for 的使用 for (arg <- 0 to 10) println(arg) 没有 for(int i=0;i<10;i++) 而且 for 中的东西都是 val 的 PS ： to ，这里是 Range ，不包含右界则是 until range 用 by 定义 step:(10 until 0) by -1 List ::: 组装两个 list 中的元素 :: 加入到 list ，只容许 el::list, 反过来不行 Nil 为空，相当于 List() l(0)=3 是不可以的，因为没有 update ， scala 中 List 是不可变的

快速入门 Tuple 从 1 开始对于一些简单对象就没必要再弄 class 了，直接返回 tuple val pair = (99, "Luftballons" ) println(pair._1) println(pair._2) Set 、 Map map(1-> "fsda" ）读取文件 import scala.io.Source for (line <- Source.fromFile(args).getLines()) println(line.length +" "+ line)

快速入门没有了 switch ， scala 变得异常强大，采用了模式匹配方式，缺省用下划线 _ 表示所有 xxx match { case "fsd":XXX case _:YYY } xxx 可以是任何东西，所有的 break 已经隐含了，准确的说是根本没有 break 语法级别里没有 break 和 continue ，绝对没有，任何跳出请加判断，因为 break 之类的可以定义成方法，现在是在 util.control 里实现了 break 的 trait 和 object （ breakable{} ）变量范围和 java 一样，但是，在嵌套范围内可以定义同外部一样的同名变量 readLine 、 readBoolean 、 readByte 、 readShort 、 readChar 、 readInt 、 readLong 、 readFloat 、 readDouble 、 readf 等等， Console 下

快速入门 Option 类型（ Option type ） , 可选类型，返回不确定类型的时候非常常用有两种形式： 1.Some(x),x 就是实际值； 2.None 例子 val capitals =Map( "France" -> "Paris" , "Japan" -> "Tokyo" ) scala> capitals get "France" res23: Option[java.lang.String] = Some(Paris) scala> capitals get "North Pole" res24: Option[java.lang.String] = None 所以这时可以用模式匹配 def show(x: Option[String]) = x match { case Some(s) => s case None => "?" }

快速入门保留字 abstract case catch class def do else extends false final finally for if implicit import match new null object override package private protected requires return sealed super this throw trait try true type val var while with yield 对比 java abstract break boolean byte case catch char class continue const default do double else extends false final finally float for goto if implements import int interface instanceof long native new null package private protected public return short static super switch synchronized this throw throws transient true try void volatile while 而 groovy abstract, as, assert, boolean, break, byte, case, catch, char, class, const, continue, def, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, in, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, threadsafe, throw, throws, transient, true, try, void, volatile, while

快速入门尾递归（ Tail Recursio ）尾递归就是从最后开始计算 , 每递归一次就算出相应的结果 , 也就是说 , 函数调用出现在调用者函数的尾部 , 因为是尾部 , 所以根本没有必要去保存任何局部变量 . 所有的 while 都可以改写成尾递归 def whileLoop(condition: => Boolean)(command: => Unit) { if (condition) { command; whileLoop(condition)(command) } else () }

加点难度类、对象、函数默认都是 public ， var 、 val 、 def 也是 public 的默认的参数只要不加 var 就是 val 的不带返回类型和 = 的 def 方法返回都是 Unit object ： scala 没有 static ，但提供了 object 来满足这种需要不可有参数单例对象： standalone object ，可认为是 final 类与 class 同名的叫做伴随对象（ companion object ）对应的类叫做伴随类，它可以与同名类互相访问对方的私有对象 object 会生成一个 $ 的 class ，仍然用原名可访问，但伴随类必须用 Object$.MODULE$ Scala 程序 main 方法：在 object 中定义 main 方法即可 def main(args: Array[String]) java 默认引入了 lang ， scala 默认引入了 Predef 及一些其他有用的东西 scala 不用在意文件名之类的，也可以往文件中放任何类或对象 scalac ； scala 脚本； fsc ； scaladoc ； sbaz ； sbt sbaz install scala-devel-docs 可以继承 Application （已 deprecate 了，用 App 代替，这两个都是 trait ）

加点难度基础类型类型 Byte ， Short ， Int ， Long 和 Char 被称为整数类型： integral type 。整数类型加上 Float 和 Double 被称为数类型： numeric type 。一个独立的 Boolean 和 java 一一对应，但都有相应的 RichXXX 类型，而且均为 final 类 String 也有 """ ，用 | 来表示一行的起始， stripMargin 方法就可以去掉前面的空格，如 println( """|Welcome to Ultamix 3000. |Type "HELP" for help.""" .stripMargin) 操作符（前中后缀，其实，应该认为没有操作符，全是方法）任一方法都是操作符，操作符也可以随意重载从左到右，有一个例外：任何以‘ :’ 字符结尾的方法由它的右手侧操作数调用，并传入左操作数 unary_ 前缀操作符，实际上如： -2.0 // Scala invokes (2.0).unary_- 前缀可用的只有 +, -, !, and ~ 其他基本和 java 一样，但是 == 不一样，相当于 equals ， eq 和 ne 方法是 java 的 == 任何包括保留字都可以用反引号当做操作符 `yield` 任何操作符都是方法调用 XX op YY 相当于 XX.op(YY)

加点难度隐式转换 class Myint(i:Int){ def ++()=i+1 } implicit def intToMyint(i:Int):Myint= new Myint(i) 内建控制结构 if ， while （ do-while ）， for ， try ， match 和函数调用没有 1>2?5:6 函数类语言一般没有循环类结构， while ， for 之类的，因为他们不返回值，比如 (line = readLine()) != "" 将永远为真，因为前者返回 Unit 相当于 () ，这个就没法在循环中判断，一般通过递归等方法实现 , 但 scala 不是纯 FP ，所以有

更进一步之 for 没有 for(int i=0;i<xxx.length;i++) ，但却比这强大简易数字循环的话 for (i <-(50 to 0) by -2) println(i) 打印文件： for （ file<-(new java.io.File(".")).listFiles ） println(file) 可以附加过滤器，但超过一个过滤器的时候要加上分号 val filesHere = ( new java.io.File( "." )).listFiles for ( file <- filesHere if file.isFile; if file.getName.endsWith( ".scala" ) ) println(file) // 可以使用大括号代替小括号环绕发生器和过滤器。使用大括号的一个好处是你可以省略一些使用小括号必须加的分号

更进一步之 for 容许内部迭代和 mid-stream （流间）变量绑定 def grep(pattern: String) = for { file <- filesHere if file.getName.endsWith( ".scala" ) line <- fileLines(file) trimmed = line.trim //if line.trim.matches(pattern) if trimmed.matches(pattern) } println(file + ": " + trimmed) grep(".*gcd.*") 可以用 for 创建新的集合，用 yield def scalaFiles = // 返回的结果是 Array[File] for { file <- filesHere if file.getName.endsWith( ".scala" ) } yield file 具体语法是： for { 子句 } yield { 循环体 }

更进一步之函数和闭包函数可以定义成方法： method ，某个对象的成员本地函数：即把函数定义在函数内部第一类函数： first-class function ，形如 XX=>YYY （生成的是类）比如 val increase = (x: Int) => x + 1 // 等号右边就是第一类函数如果超过一行的话，用大括号包起来可以使用短格式或者占位符代替参数，比如 filter （ x=>x>1 ）或者 filter(_>1) 或者 filter(1<) 甚至可以 val f = (_: Int) + (_: Int) //f(5, 10) 调用偏应用函数： partially applied function （我个人认为应该叫部分应用函数） def sum(a: Int, b: Int, c: Int) = a + b + c val a = sum _ //=sum 是不行的，这时是定义函数，不可以简略，只有下面 foreach 那种确定要传入的是函数的情况下才可以省略 val b = sum(1, _: Int, 3)

更进一步之函数和闭包闭包闭包（ Closure ）是词法闭包（ Lexical Closure ）的简称，是引用了自由变量（未绑定）的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。最早实现闭包的程序语言是 Scheme 。举个例子： (x: Int) => x + more more 是个自由变量： free variable ，因为函数文本自身没有给出其含义 ; 相对的， x 变量是一个绑定变量： bound variable ，因为它在函数的上下文中有明确意义不带自由变量的函数文本，如 (x: Int) => x + 1 ，被称为封闭术语： closed term ，这里术语： term 指的是一小部分源代码而例子则是是开放术语： open term 如果要是用这个开放术语的例子，则要定义 more 是什么，比如初始化为 0 ，依照这个函数文本在运行时创建的函数值（对象）被称为闭包： closure 。

更进一步之函数和闭包函数的参数重复参数，用 * 来表示 def echo(args: String*) = for (arg <- args) println(arg) 实际组织形式是数组，但是直接调用是不行的命名参数 def speed(distance: Float, time: Float): Float =distance / time speed(time = 10, distance = 100) 默认参数 def c(a:Int=6)={println(a)} 传名参数 by-name parameter 采用 :=> 方式，大部分会用于 boolean 的判断，不会再调用的时候执行而是直接引入被调用的地方

更进一步之函数和闭包高阶函数 :higher-order function 指把另一个函数作为参数或返回值的函数 def filesMatching(query: String, matcher: (String, String) => Boolean) = { for (file <- filesHere; if matcher(file.getName, query)) yield file } def filesEnding(query: String) = filesMatching(query, _.endsWith(_)) def filesContaining(query: String) = filesMatching(query, _.contains(_)) def filesRegex(query: String) = filesMatching(query, _.matches(_)) scala 大规模使用了高阶函数，比如，我想从一个 list 中打印出所有的奇数，这点在下面详解 List 的时可看到 def containsOdd(nums: List[Int]) = nums.exists(_ % 2 == 1)

更进一步之函数和闭包克里化： Currying ，又叫局部调用是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。例子： def curriedSum(x: Int)(y: Int) = x + y val onePlus = curriedSum(1)_ Haskell Brooks Curry

更进一步之类仍然是 abstract 定义抽象类， extends 继承 final 啥的也都在 Scala 里禁止在同一个类里用同样的名称定义字段和方法参数化字段，又称为类参数 class ArrayElement( // 请注意，小括号 val contents: Array[String] ) extends Element Scala 里所有重载了父类具体成员的成员都需要修饰符 override

更进一步之类 scala 的继承树所有都继承自 Any ，而 Null 和 Nothing 是所有的子类 Any 有如下方法： def != (arg0: Any): Boolean def ## (): Int def == (arg0: Any): Boolean def asInstanceOf [T0] : T0 def equals (arg0: Any): Boolean def hashCode (): Int def isInstanceOf [T0] : Boolean def toString (): String

更进一步之类根类 Any 有两个子类： AnyVal 和 AnyRef 。 AnyVal 是 Scala 里每个内建值类的父类。有九个这样的值类： Byte ， Short ， Char ， Int ， Long ， Float ， Double ， Boolean 和 Unit 。其中的前八个对应到 Java 的原始类型，它们的值在运行时表示成 Java 的原始值。 Scala 里这些类的实例都写成文本。值类都被定义为既是抽象的又是 final 的类 Any 的另一个子类是类 AnyRef 。这个是 Scala 里所有引用类的基类 ,AnyRef 实际就是类 java.lang.Object 的别名。 Scala 类与 Java 类不同在于它们还继承自一个名为 ScalaObject 的特别的记号特质， ScalaObject 包含了 Scala 编译器定义和实现的方法，目的是让 Scala 程序的执行更有效

更进一步之类另一个值类， Unit ，大约对应于 Java 的 void 类型；被用作不返回任何有用结果的方法的结果类型。 Unit 只有一个实例值，被写作 () 类 Null 是 null 类型的引用；它是每个引用类（就是说，每个继承自 AnyRef 的类）的子类。 Null 不兼容值类型。类型 Nothing 在 Scala 的类层级的最底端；它是任何其它类型的子类型。 Nothing 的一个用处是它标明了不正常的终止。

更进一步之特质 trait trait 是 Scala 里代码复用的基础单元。特质封装了方法和字段的定义，并可以通过混入到类中重用它们。不像类的继承那样，每个类都只能继承唯一的超类，类可以混入任意个特质。用 extends 或 with 混入（ mix-in ） trait 特质就像是带有具体方法的 Java 接口。第一点，特质不能有任何“类参数”，也就是说，传递给类的主构造器的参数第二点，不论在类的哪个角落， super 调用都是静态绑定的，在特质中，它们是动态绑定的混入的次序非常重要 , 粗略地说，越靠近右侧的特质越先起作用

更进一步之特质 trait scala 线性继承算法： 1. 自己； 2. 从右边开始继承，并把每一个所继承的线性继承累计进入线性继承； 3. 从左往右看，把每一个右边已有的继承去掉重复的； 4. 加上 ScalaObject ， AnyRef ， Any 举个例子： class Human trait Woman extends Human trait Driver extends Human trait FemaleDriver extends Driver trait MarriedWoman extends Woman trait SixFingers extends Human class MarriedSixFingersFemaleDriver extends MarriedWoman with FemaleDriver with SixFingers 最终的结果就是 SF FD D MW W H （ SO AR A ）

更进一步之包、引用、断言包机制，和 java 一样，但可以用类似命名空间那样的 package xx{} 继续定义引用仍然是 import ，但这里不用 * 而是用占位符 _ 表示整个包下所有东西，也可以引入类的所有东西（成员或方法）可以随时 import 可以选择引用，或改名引用 import Fruits.{Apple , Orange} ， import java.{sql => S} ， import java.sql.{Date => SDate} ， import Fruits.{Apple => McIntosh, _} 特例： import Fruits.{Pear => _, _} 这个引用了除 Pear 之外的所有 Fruits 成员总结就是 : 1. 简单名 x 。把 x 包含进引用名集。 2. 重命名子句 x => y 。让名为 x 的成员以名称 y 出现。 3. 隐藏子句 x => _ 。把 x 排除在引用名集之外。全包括‘ _’ 。引用除了前面子句提到的之外的全体成员。如果存在全包括，那么必须是引用选择的最后一个。

更进一步之包、引用、断言默认引用 import java.lang._ // java.lang 包的所有东西 import scala._ // scala 包的所有东西 import Predef._ // Predef 对象的所有东西 Predef 是个非常牛的东西，需要单用一节课去讲留个作业：如果真的想学 scala 的话，把 Predef 看了可见范围所有默认都是 public ， private 和 protected 仍然存在。当定义了 private [bobsrockets] 。这就是说这个类对包含在 bobsrockets 包的所有的类和对象可见类把它所有的访问权限共享给伴生对象，反过来也是如此。包对象每个包都可以有一个包对象（ package object ），把所有包级别共同的可以定义在内， 2.8 加入断言 assert ， assume ， require

更进一步之 case 类和模式匹配 case 类（ Case Classes ） Case 类用 case 关键词修饰 1. 会在编译时加入一个工厂方法，不用再 new 出来，可以直接生成。 2. 所有的类参数会加上 val ，也就是自动转变成 field ； 3. 加入一些自然实现的方法 toString,hashCode, and equals ； 4. 自动加入了一个 copy 方法模式匹配（ Pattern Matching ）： selector match { alternatives } 而 alternatives 都是从 case 开始，一个模式和一或多个表达式去判断模式是否匹配，还有一个 => 所有 break 都是隐含的（而且没有 break 这个东西）

更进一步之模式匹配通配符匹配 _ 可以通配所有，类似 default ，但是在 pattern 中出现的话就是通配中间的东西了常量匹配、变量匹配（正则 Regex() 或者 .r ） scala> import math.{E, Pi} import math.{E, Pi} scala> val pi = math.Pi pi: Double = 3.141592653589793 scala> E match { | case `pi` => "strange math? Pi = "+ pi | case _ => "OK" | } res0: java.lang.String = OK scala> Pi match { | case `pi` => "strange math? Pi = "+ pi | case _ => "OK" | } res1: java.lang.String = strange math? Pi = 3.141592653589793 val Dpi = math.Pi Pi match { case Dpi => "strange math? Pi = "+ pi case _ => "OK" }

更进一步之模式匹配构造器匹配、序列化匹配 expr match { case List(0, _, _) => println("found it") //case List(0, _*) => println("found it") case _ => } tuple 匹配 expr match { case (a, b, c) => println("matched "+ a + b + c) case _ => } 类型匹配 x match { case s: String => s.length case m: Map[_, _] => m.size case _ => -1 } 注意的是，类型是消除的，不能用泛型匹配，比如 case m: Map[Int, Int] => true ，但唯一例外的是 Array ，可以泛型匹配

更进一步之模式匹配变量绑定 expr match { case UnOp("abs", e @ UnOp("abs", _)) => e case _ => } 模式保护 e match { case BinOp("+", x, x) => BinOp("*", x, Number(2)) case _ => e } // 编译不过，因为出现了两个 x ，而 scala 的模式要求是线性模式 def simplifyAdd(e: Expr) = e match { case BinOp("+", x, y) if x == y =>BinOp("*", x, Number(2)) case _ => e } 模式保护就是指在模式后以 if 开头的 boolean 表达式

更进一步之封闭类封闭类（ Sealed classes ）非封闭类在 match 可用 @unchecked 取消 warning sealed abstract class HttpMethod() case class Connect(body: String) extends HttpMethod case class Delete (body: String) extends HttpMethod case class Get (body: String) extends HttpMethod case class Head (body: String) extends HttpMethod case class Options(body: String) extends HttpMethod case class Post (body: String) extends HttpMethod case class Put (body: String) extends HttpMethod case class Trace (body: String) extends HttpMethod def handle (method: HttpMethod) = method match { case Connect (body) => println("connect: " + body) case Delete (body) => println("delete: " + body) case Get (body) => println("get: " + body) case Head (body) => println("head: " + body) case Options (body) => println("options: " + body) case Post (body) => println("post: " + body) case Put (body) => println("put: " + body) case Trace (body) => println("trace: " + body) }

更进一步之模式匹配的例子 scala> val myTuple = (123, "abc") myTuple: (Int, java.lang.String) = (123,abc) scala> val (number, string) = myTuple number: Int = 123 string: java.lang.String = abc

更进一步之模式匹配的例子 scala> val exp = new BinOp("*", Number(5), Number(1)) exp: BinOp = BinOp(*,Number(5.0),Number(1.0)) scala> val BinOp(op, left, right) = exp op: String = * left: Expr = Number(5.0) right: Expr = Number(1.0) for 也是有模式匹配的 for ((country, city) <- capitals) println( "The capital of " + country + " is " + city)

更进一步之模式匹配的例子 scala> val results = List(Some("apple"), None,Some("orange")) results: List[Option[java.lang.String]] = List(Some(apple),None, Some(orange)) scala> for (Some(fruit) <- results)println(fruit) apple orange

更进一步之 List 和 Array 类似，但是： 1.List 不可变； 2.List 是递归的， Array 是平的 1.List 是同质的（ homogeneous ），即 List 中的东西都是同类的 2.List 是协变的（ covariant ），举例： S 是 T 的子类，那么 List[S] 是 List[T] 的子类 List() 是 List[Nothing] 构造 List ： List 有两个东西构成： 1. Nil ，为空 list ； 2.:: （ cons ），中缀符，连接了元素（前面）和 list （后面）注意这三个是类， List 本身是 +T 的 abstract 类，有一个伴随类以用于初始化 Nil 继承自 List[Nothing] ，由于是协变的，所以适用于所有 List 对象 List(1, 2, 3) // 1 :: (2 :: (3 :: Nil))//1::2::3::Nil //1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)

更进一步之 List 所有的对 List 的操作都可以定义到下面的三个： 1.isEmpty ：是否为空 2.head ： list 中的第一个元素 3.tail ： list 除了第一个剩下的元素这三个方法在 List 中是 abstract 的，被 Nil 和 :: 定义 :: 在模式匹配时，操作符的定义不同， x::xs 是一个特殊中缀操作模式，并不是 x.::(xs) ，而是 ::(x,xs) // 下面的例子是插入排序留作业自己看吧 def isort(xs: List[Int]): List[Int] = xs match { case List() => List() case x :: xs1 => insert(x, isort(xs1)) } def insert(x: Int, xs: List[Int]): List[Int] = xs match { case List() => List(x) case y :: ys => if (x <= y) x :: xs else y :: insert(x, ys) }

更进一步之 List ::: 也是右联合的，和 :: 一样，组合 list 内的元素为新 list 实现同样的功能 def append[T](xs: List[T], ys: List[T]): List[T] =xs match { case List() => ys case x :: xs1 => x :: append(xs1, ys) } length xs length// 返回长度，而不是 size(), 由于 list 是递归的，所以用这个方法需要谨慎，因为它的定义 var these = self var len = 0 while (!these.isEmpty) { len += 1 these = these.tail } len 也就是说，为了得到长度需要遍历整个 list ，和 LinkedList 不一样， LinkedList 在内部有个 size 域

更进一步之 List init ：除了最后一个以外的 list last ：最后一个，都不能对 () 使用 ------------------- 这两个也要遍历整个 list------------------- reverse ：反转，同时，也是自反的 xs.reverse.reverse equals xs drop ：扔掉前 n 个 , take ：得到前 n 个 , splitAt ：从 n 处砍成两个 list ，当 n 大于长度时，第一个返回 () ，第二个全部 xs splitAt n 相当于 (xs take n, xs drop n) 选择 list 中的元素通过 apply ，也就是 xs(1) 实际上是 xs.apply(1) ，还可以写成 xs apply 1, 复杂度是 n ，所以 list 很适合随机取 indices 可以返回元素的序号，返回的是 Range 类型

更进一步之 List flatten ：扁平化多个 list 成一个，只对 list 本身也是由 list 组成的 list 管用 scala> List(List(1, 2), List(3), List(), List(4, 5)).flatten res14: List[Int] = List(1, 2, 3, 4, 5) zip ：将两个 list 组成配对的 list （一般这个配对就是指 Tuple ） scala> val xs=List(1,2,3);val xs1=List('a','b','n') xs: List[Int] = List(1, 2, 3) xs1: List[Char] = List(a, b, n) scala>val xs2= xs zip xs1 xs2: List[(Int, Char)] = List((1,a), (2,b), (3,n)) zipWithIndex ：用序号组合 scala> xs1 zipWithIndex res6: List[(Char, Int)] = List((a,0), (b,1), (n,2))

更进一步之 List unzip ： zip 的反例 scala> xs2 unzip res6: (List[Int], List[Char]) = (List(1, 2, 3),List(a, b, n)) toString ： scala> xs2 toString res12: String = List((1,d), (2,fsd), (das,fsda)) mkString ：组装成需要的 String ，一种是提供三个参数，一种是不提供或一个参数 scala> xs2 mkString " and " res14: String = (1,d) and (2,fsd) and (das,fsda) scala> xs2.mkString("a list:",","," end") res15: String = a list:(1,d),(2,fsd),(das,fsda) end

更进一步之 List sum 、 product 、 min 、 max iterator, toArray, copyToArray （当然 Array 也有 toList ） xs copyToArray (arr, start) ，把 xs 拷到 arr 从 start 开始的位置，覆盖， arr 是不动的

更进一步之 List 高阶方法 map ： xs map f ，表示着返回一个有 xs 里的每个元素执行一遍 f 的结果的 list val xs=List("fsdaFsdaFsdaFdsa","gfdh","fFDS") scala> xs map (_.length) res25: List[Int] = List(16, 4, 4) for (x <- expr1) yield expr2 就相当于 expr1.map(x => expr2) flatMap ：对 list 中的 list 的每个元素进行操作 scala> xs map (_.toList) res26: List[List[Char]] = List(List(f, s, d, a, F, s, d, a, F, s, d, a, F, d, s, a), List(g, f, d, h), List(f, F, D, S)) scala> xs flatMap (_.toList) res27: List[Char] = List(f, s, d, a, F, s, d, a, F, s, d, a, F, d, s, a, g, f, d, h, f, F, D, S)

更进一步之 List 高阶方法 foreach 每一个进行 f ，返回最终结果永远是 Unit ，也就是说，这里的 f 是一个过程计算，不返回东西 scala> var sum=0;List.range(1,5) foreach (sum+=_) sum: Int = 10 filter ：过滤 scala> List.range(1,10) filter (_ %2==1) res34: List[Int] = List(1, 3, 5, 7, 9) partition ：和 filter 相似，但会返回两个 list 组成的 pair ，前面是符合的，后面是不符合的 scala> List.range(1,10) partition (_ %2==1) res36: (List[Int], List[Int]) = (List(1, 3, 5, 7, 9),List(2, 4, 6, 8))

更进一步之 List 高阶方法 find ：只返回第一个对的，没有则返回 None ，也就是说返回是可选类型值（ optional value ） scala> List.range(1,10) find (_ %2==1) res37: Option[Int] = Some(1) takeWhile 、 dropWhile ：得到前面最多个符合的 list ；去掉前面最多个符合的 list scala> List.range(1,10) takeWhile (_ <3) // 如果第一个就不符合的话返回 () res43: List[Int] = List(1, 2) scala> List.range(1,10) dropWhile (_ <3) // 从前往后第一个不符合就返回全部 res45: List[Int] = List(3, 4, 5, 6, 7, 8, 9) span ：上两个组合相当于 xs span p equals (xs takeWhile p, xs dropWhile p)

更进一步之 List 高阶方法 forall ：返回所有的是否都满足 f exists ：存在有满足 f 的 sortWith ：排序，根据传入的 f 进行排序，比如按照字段长度什么的 Folding lists: /: and :\ list 提供了两个方法 sum 和 product ，在上面已经提到过，那么，用左联定的话： sum 的定义 def sum[B >: A](implicit num: Numeric[B]): B = foldLeft(num.zero)(num.plus) product 的定义 def product[B >: A](implicit num: Numeric[B]): B = foldLeft(num.one)(num.times) 这里用到的就是左联， foldLeft ，也就是 /: 自己实现的话就是 (0 /: xs) (_ + _) (1 /: xs) (_ * _)

更进一步之 List 左右联左联（ fold left ）操作： (z /: xs) (op) 有三个组成部分， z ：初始值； xs ：要参与操作的 list ； op ：二元操作例子： (z /: List(a, b, c)) (op) 就是 op(op(op(z, a), b), c) 用图来讲就是左倾树举个例子，我想设计一个方法，传入一个 list ，一个默认值，算出总和，那么 scala> def sum(defaultValue:Int,xs:List[Int]):Int=(defaultValue /: xs) (_+_) 那么 :\ 就是右联，右倾树 (List(a, b, c) :\ z) (op) equals op(a, op(b, op(c, z))) 留个作业：如何用左联实现 reverse

更进一步之 List 高阶方法 list 的伴随类 object a) List.apply ：其实上边已经用了很多了，就是 List(1,2,3) 这个就是 apply 出来的 b) List.range(from, until) ：上边也用过了 c) List.fill ：这是一个 curry 函数，生成若干维度若干个的同样填充元素的 list d) List.tabulate ：和上边一样，只不过第二个参数传的是 f ，返回的也是 f 后的 list e) List.concat ：将若干个 list 组成一个 List 有个问题，它只在处理 head::tail 很好，但如果你想在后边 append 的话就郁闷了，这时候就要用 ListBuffer ，这是一个可改变的集合， xs += el 用来 append ， el +=: xs 用于从前面添加，复杂度 1 ，然后用 toList 可以得到 list （同样， ArrayBuffer 提供了可以删除头或尾的方法） Stream ，和 List 一样，用 cons 代替 :: ，用 append 代替 ::: ，比如要算出 50000 以下第 17 个可以被 17 整除的是谁 , 我可以直接写 List.range(50000,49500,-1).filter(_ % 17 ==0)(16) 但 ...

更进一步之 StringOps 和 Tuple 由于 Predef 提供了 String 到 StringOps 的隐式转换，于是就有了很多东西， StringOps 是集合类的 "fsdfsdfsdfsdFsd".exists(_.isUpper) Tuple ，也是集合类，投连险状态也用可以用这个来解决

更进一步之 Set 和 Map Set 和 Map ，都有可变不可变两种，默认不可变 Set 提供了 + 、 - 、 ++ 、 -- 、 & 等等常用方法 Map 有三种赋值方式，一种是 map(1)="a", 一种是 map(1->"a") ， map += 1 -> "a" 同样也有那些方法，然后多了 keys 、 keySet 、 values 等自有的方法最有意思的就是，会根据你的元素数量决定用什么， Map 同理（这点应该说是为了性能的极致，可参见 Tuple 、 Function 、 Product 等，定义了 20 余个）元素数量用 0 scala.collection.immutable.EmptySet 1 scala.collection.immutable.Set1 2 scala.collection.immutable.Set2 3 scala.collection.immutable.Set3 4 scala.collection.immutable.Set4 5 or more scala.collection.immutable.HashSet 同样也有 TreeMap 和 TreeSet ，排序的集合 Set(1, 2, 3) == Set(3, 2, 1) //List 为 false Set 的 +- 只能对单一数据，对 Set 操作用 ++ 、 -- 、 ** （返回共同数据）

更进一步之类型参数化类型参数化（ Type Parameterization ）类成员 (type member): 用标识 type 声明在 scala 中泛型默认是非变的（ nonvariant ）或者说严格的（ rigid ）子类型在定义时泛型加入 + 标志着子类型是协变（ covariant ）的，与之对应的 - 标志着子类型是逆变（ contravariant ）的类型是协变、逆变还是非变的，被称为参数的变化（ variance ）， + 、 - 被称为变化注解 U >: T 这是类型下界 (lower bound) 的定义，也就是 U 必须是类型 T 的父类 ( 或本身，自己也可以认为是自己的父类 ) 。 S <: T 这是类型上界（ upper bound ）的定义，也就是 S 必须是类型 T 的子类（或本身，自己也可以认为是自己的子类 ) 。这里隐含了一个 type ，也就是类成员定义

更进一步之类型参数化 lazy 变量，在 val 第一次被使用的时候才会被初始化，举个反例 scala> object Demo {val x = { println("initializing x"); "done" }} scala> Demo initializing x res3: Demo.type = Demo$@17469af scala> Demo.x res4: java.lang.String = done 结构子类型（鸭子类型 Duck-typing ）举个例子，我需要一个通用的打印后关闭，流、文件都行 def using[T <: { def close(): Unit }, S](obj: T)(operation: T => S) = { val result = operation(obj) obj.close() result }

更进一步之隐式转换隐式转换（ Implicit Conversions ）用 implicit 实现，当编译器看到一个 X ，而这时应该需要的是 Y ，那么编译器就去找隐式转换方法 implicit def xtoy(x:X):Y={bulabula... // 实现 x 到 Y 类型的转化 } 留个作业，回去看 -> ，这个实际上是 ArrowAssoc 类，定义在 Predef 里，看看在 map 定义的时候 -> 返回的到底是什么 implicit 不只可以隐式转换类，还可以出现在参数里，变成隐式参数视界 view bound S <% T ，与 <: 类似，但是要求 S 可以当成右边的 T 来对待，并不是说 S 是 T 的子类，而可以对待就是指 S 可以转换为 T scala -Xprint:typer

更进一步之 apply 和 unapply apply 组装器 unapply 提取器 object EMail { def apply(user: String, domain: String) = user + "@" + domain def unapply(str: String): Option[(String, String)] = { val parts = str split "@" if (parts.length == 2) Some(parts(0), parts(1)) else None } }

更进一步之 Annotation @scala.reflect.BeanProperty @serializable @deprecated @volatile @tailrec @unchecked @native @getter @setter

更进一步之 XML XML ：原生语言支持，直写就可以， XML 对象对应是 scala.xml.Elem <a>hello world</a> // 当中间的内容需要运算得出时，用花括号括起来 <a> { "hello" + ", world" } </a> //text 方法可返回中间的内容 scala> <a>Sounds <tag/> good</a>.text res8: String = Sounds good \ 方法用于找元素 byTag \\ 是所有中找元素 byTag

更进一步之 XML 找东西 scala> <a><c>hello</c></a> \ "b" res10: scala.xml.NodeSeq = <c>hello</c> scala> <a><c>hello</c></a> \ "c" res11: scala.xml.NodeSeq =NodeSeq() scala> <a><c>hello</c></a> \\ "c" res12: scala.xml.NodeSeq = <c>hello</c> scala> <a><c>hello</c></a> \ "a" res13: scala.xml.NodeSeq =NodeSeq() scala> <a><c>hello</c></a> \\ "a" res14: scala.xml.NodeSeq = <a><c>hello</c></a>

更进一步之 XML 元素值 @ 方法找元素属性值 scala> val joe = <employee name="Joe" rank="code monkey" serial="123"/> joe: scala.xml.Elem = <employee rank="code monkey" name="Joe" serial="123"></employee> scala> joe \ "@name" res15: scala.xml.NodeSeq = Joe scala> joe \ "@serial" res16: scala.xml.NodeSeq = 123

更进一步之 XML 模式匹配快捷的模式匹配 def proc(node: scala.xml.Node): String = node match { case <a>{contents}</a> => "It's an a: " + contents case {contents} => "It's a b: " + contents case <a>{contents @ _*}</a> => "It's an a: " + contents case {contents @ _*} => "It's a b: " + contents case _ => "It's something else." }

更进一步之 Io 系列写文件 import java.io._ val writer = new PrintWriter( new File( "symbols.txt" )) writer write "AAPL" writer.close() 读文件 Source.fromFile( "ReadingFile.scala" ).foreach { print } 读网络文件 import scala.io.Source import java.net.URL Source.fromURL( new URL( "http://www.scala-lang.org/docu/files/api/index.html" )).foreach { print } 读 xml import scala.xml._ val stocksAndUnits = XML.load( "http://www.verycd.com/sto/feed" ) 写 xml XML save ( "d:/123.xml" ,stocksAndUnits, "utf-8" )

更进一步之 Actor 是一个类似线程的实体，拥有一个邮箱（ mailbox ）来接受信息。 Scala Actor 线程模型可以这样理解：所有 Actor 共享一个线程池，总的线程个数可以配置，也可以根据 CPU 个数决定；当一个 Actor 启动之后， Scala 分配一个线程给它使用，如果使用 receive 模型，这个线程就一直为该 Actor 所有，如果使用 react 模型， Scala 执行完 react 方法后抛出异常，则该线程就可以被其它 Actor 使用。通过继承 scala.actors.Actor 并实现 act 方法来使用 import scala.actors._ object SillyActor extends Actor { def act() { for (i <- 1 to 5) { println( "I'm acting!" ) Thread.sleep(1000) } } }

更进一步之 Actor 或者，你可以引入 Actor ，然后直接定义一个立即执行的 actor import scala.actors.Actor._ val seriousActor2 = actor { for (i <- 1 to 5) println( "That is the question." ) Thread.sleep(1000) } 这两个都是直接运行的 actor ，但实际上 actor 是用于接受信息并处理的，用 ! 发信息，用 receive 接受信息 ! 工作是异步的，想要同步的话用 !? 即可但是 ! 是要等到 receive 的返回的，会阻塞继续发送信息，那样的话用 !! 的 Future 模式，它发出后会立刻返回执行，得到的时候才会阻塞 ? 用来倒下一个 mailbox 里的东西 mailboxSize ：邮箱中未被处理的信息数 sender ! "" 相当于 reply("") // 用于返回信息

更进一步之 Actor 来个等待的例子 import scala.actors.Actor._ val echoActor = actor { loop{ //while (true) receive { case msg => println( "received message: " + msg) } } }

更进一步之 Actor 具体是这样的，每一条信息进入到邮箱里，首先调用偏方法的 isDefinedAt 判断是否有对应的 case 用于匹配处理这条信息，而且只针对第一个满足匹配的进行处理，然后调用偏方法的 apply 方法如果你想要把当前的线程当成 actor 的话，可以用 Actor.self receive 同时还提供了一个限时的方法 receiveWithin 后面接毫秒数，超时则退出（用 case TIMEOUT ） react 和 receive 不同，它并不会返回东西，而是返回 Nothing ，只是执行运算，不会保存当前线程的调用堆栈，所以要比 receive 高效得多但由于不会返回，也就意味着跟随在 react 后边的都不会执行，因此， react 应作为 actor 最后的东西同样有 reactWithin 用 loop 的时候还有个方法 loopWhile receive 和 react 的差别在于 receive 需要阻塞当前 Java 线程， react 则仅为阻塞当前 Actor ，但并不会阻塞 Java 线程，因此 react 模式更适合于充分发挥 coroutine 带来的原生线程数减少的好处，但 react 模式有个缺点是 react 不支持返回。 remoteActor, 远程的，多了注册，多了 alive 等方法，提供远程试用

更进一步之 swing 超简化的 swing ，呃，这块我没兴趣，所以我就没看，但是可以说比 groovy 和 java 都要简单 import scala.swing._ import event._ object SampleGUI extends SimpleGUIApplication { def top = new MainFrame { title = "A Sample Scala Swing GUI" val label = new Label { text = "hello" } val button = new Button { text = "Click me" } contents = new FlowPanel { contents += label contents += button } listenTo(button) reactions += { case ButtonClicked(button) => label.text = "You clicked!" } } }

更进一步之 2.9.0.1 加入了平行集合类，在执行 `foreach`, `map`, `filter` 会充分使用多核处理 App trait ，替代了 Application ，快速的应用特质延迟初始化的 trait REPL(read-eval-print-loop) 强化， Runner 强化新的一些 annotation 更强大的 try catch finally 新的 sys 包，集合新加入了 collectFirst, maxBy, minBy, span, inits, tails, permutations, combinations, subsets 等方法 N 多 bug 修复

更进一步之 scala 图书

Scala

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Scala (20)

Scala