scala学习_scala load

程序运行方式：

一是在/opt/scala-2.10.4/bin目录下执行scala /opt/tmp/hello.scala【运行脚本文件，后面可跟参数】；

二是执行scala命令，进入交互界面，再使用命令scala> :load /opt/tmp/hello.scala【导入脚本文件，可继续执行scala> hello，不知如何加参数？】；

三是执行scala，进入交互界面，在命令行中编写程序并运行。在交互界面中可执行scala> :help查看帮助。

关键字：

Val 常量

Var 变量

Def 函数（也是对象，Everything is an object），如def max(x: Int, y: Int): Int = if (x < y) y else x；def greet() = println("Hello, world!")；匿名函数可省略def，如(x: Int, y: Int) => if (x < y) y else x；通配符参数_，如val a=max(5,_:Int),再执行a(2),a(7)等；可变参数，如def capitalizeAll(args: String*) = {args.map { arg =>arg.capitalize }}。

Class 类，如class Calculator(brand: String)，创建类时可带参数，可使用关键字new生成对象。可使用关键字Extends继承，可使用关键字Abstract抽象，抽象类不能实例化。

Traits  类似接口，表示一系列可以扩展或者混入到你的类里的成员和行为，并可通过关键字with让一个类扩展多个trait，如class BMW extends Car with Shiny【trait Car, trait Shiny，一个类可以扩展多个trait，但是只能扩展一个抽象类；但如果需要在构造类的时候传入参数的话，那就用抽象类。抽象类的构造器可以传入参数，trait则不能】

Object  对象，对象都是用来保持一个类的单个实例。经常在工厂里用到。类和对象可以重名。这样的对象被称为“伴随对象（Companion Object）”。我们一般在工厂里使用伴随对象。对象对于组织静态函数是很有用的。

Override  函数重载

Package   包

Match-case  模式匹配

case class 可以用来方便地存储和匹配类的内容，你不需要用new来构造它们。case class的设计就是为了进行模式匹配。

try-catch-finally        异常处理，也使用模式匹配

其他：

泛型：

class Reference[T] {

private var contents: T = _

def set(value: T) { contents = value }

def get: T = contents

}

object IntegerReference {

def main(args: Array[String]) {

val cell = new Reference[Int]

cell.set(13)

println("Reference contains the half of " + (cell.get * 2))

}

}

数组：

val greetStrings = new Array[String](3)

greetStrings(0) = "Hello"

greetStrings(1) = ", "

greetStrings(2) = "world!\n"

for (i <- 0 to 2)

print(greetStrings(i))

集合：

List：可用:::组合多个list，用::组合多个元素。val numbers = List(1, 2, 3, 4)

Set：无重复元素

Tuple：可以包含多种类型，位置从1开始。val pair = (99, "Luftballons");println(pair._1); println(pair._2)

Map：Map( 1 -> "one", 2 -> "two") //Map((1,"one"),(2,"two"))【类似一个二元元组的元素组，每个元素的键值可以用._1和._2标识】

函数组合器：

Map numbers.map((i: Int) => i * 2) //List(2, 4, 6, 8)

Foreach 与map相似，但无返回值。numbers.map((i: Int) => i * 2)

Filter移除任何使得传入的函数返回false的元素。numbers.filter((i: Int) => i % 2 == 0) //List(2, 4)

Zip把两个列表的元素合成一个由元素对组成的列表里。List(1, 2, 3).zip(List("a", "b", "c")) //List((1,a), (2,b), (3,c))

Partition 根据断言函数的返回值对列表进行拆分。numbers.partition(_ %2 == 0) //(List(2, 4),List(1, 3))

Find 返回集合里第一个匹配断言函数的元素。numbers.find((i: Int) => i > 2) //3

Drop 丢弃前i个元素。numbers.drop(2) //List(3, 4)

DropWhile移除前几个匹配断言函数的元素。numbers.dropWhile(_ % 2 != 0) //List(2, 3, 4)【因为2满足条件，所以比较结束】

FoldLeft/foldRight numbers.foldLeft(0)((m: Int, n: Int) => m + n) //10【0是起始值（注意numbers是一个List[Int])，m是累加值】

Flatten 把嵌套的结构展开。List(List(1, 2), List(3, 4)).flatten //List(1, 2, 3, 4)

FlatMap是一个常用的combinator，它结合了map和flatten的功能。flatMap接收一个可以处理嵌套列表的函数，然后把返回结果连接起来。List(List(1, 2), List(3, 4)).flatMap(x => x.map(_ * 2)) //List(2, 4, 6, 8)

并发：

actor消息模型，类似Erlang，首选，Lift和akka也实现了自己的actor模型。

Scala会建立一个线程池共所有Actor来使用。receive模型是Actor从池中取一个线程一直使用；react模型是Actor从池中取一个线程用完给其他Actor用。

react模型：

import scala.actors._

object Actor1 extends Actor { // 或者class

// 实现线程

def act() { react { case _ =>println("ok"); exit} }

}

//发送消息：

Actor1.start ! 1001 // 必须调用start

或：

import scala.actors.Actor._

val a2 = actor { react { case _ =>println("ok") } } // 马上启动

//发送消息：

a2 ! "message" // 不必调用start

receive模型：

import actors.Actor, actors.Actor._

val a1 = Actor.actor {

var work = true

while(work) {//要反复处理消息，receive外层用while(...)

receive { // 接受消息, 或者用receiveWith(1000)

case msg:String => println("a1: " + msg)

case x:Int => work = false; println("a1 stop: " + x)

}

}

}

a1 ! "hello" // "a1: hello"

a1 ! "world" // "a1: world"

a1 ! -1 // "a1 stop: -1"

a1 ! "no response :("

接收也可以用react、loop【特点：从不返回；要反复执行消息处理，react外层用loop，不能用while(..)；通过复用线程，比receive更高效，应尽可能使用react】：

val a1 = Actor.actor {

react {

case x:Int => println("a1 stop: " + x)

case msg:String => println("a1: " + msg); act()

    }

}

如果不用退出的线程，可使用loop改写如下：

val a1 = Actor.actor {

loop {

react {

case x:Int => println("a1 stop: " + x); exit()

case msg:String => println("a1: " + msg)

    }

  }

}

提示：

! 发送异步消息，没有返回值。

!?发送同步消息，等待返回值。（会阻塞发送消息语句所在的线程）

!!发送异步消息，返回值是 Future[Any]。

? 不带参数。查看 mailbox 中的下一条消息。

其他方式：

Thread、Runnable

java.util.concurennt

3rd并发框架如Netty，Mina

WEB程序：

Lift框架：

软件包：lift-lift_26_sbt-cf8327c.tar

# cd lift-lift_26_sbt-cf8327c/scala_211/lift_basic

# ./sbt

> container:start【测试http://192.168.1.221:8080】

Play2框架：

软件包：typesafe-activator-1.3.2-minimal.zip/typesafe-activator-1.3.2.zip（play2.3.8）【貌似需要有图形界面才能正常运行】

# cd activator-1.3.2

# ./activator ui

与JAVA交互：

import java.util.{Date, Locale}

import java.text.DateFormat

import java.text.DateFormat._

object FrenchDate {

def main(args: Array[String]) {

val now = new Date

val df = getDateInstance(LONG, Locale.FRANCE)

println(df format now)

}

}