《七周七语言：理解多种编程范型第5章 Scala》笔记

5.1 关于Scala

5.1.1 与Java的密切关系

Scala运行在Java虚拟机上，这使得Scala可以和现存的应用同时运行。
Scala可以直接使用Java类库，使得开发人员可以利用现有的框架和遗留代码。
Scala和Java一样都是静态类型语言，因此这两种语言遵循一样的编程哲学。
Scala的语法与Java比较接近，使得开发人员可以快速掌握语言基础。
Scala既支持面向对象泛型也支持函数式编程泛型，这样开发人员就可以逐步在代码中运用函数式编程的思想。

5.1.2与Java的不同之处

类型推断

Scala类型推断的极限在哪里？什么情况下必须要指定变量的类型？

函数式编程概念

可以通过不同方式使用已有的函数构造出新函数。

不变量

变量是否可变必须一开始就明确，如果不知道变量是否可变，那么就应该指定为不可变的。
在这种理念的指导下，Scala会要求你明确地决定一个变量是否可变。

高级程序构造

5.1.4函数式语言特性

函数式程序由函数组成。
函数总是具有返回值。
函数对于相同的输入总是会返回相同的值。
函数式程序禁止改变状态或修改数据。一旦你设置了一个值，就无需再管它了。

Scala并不是一门纯函数式编程语言。

5.2 第一天

5.2.1 Scala 类型

Scala Hello World

整数是对象。

scala> "abc" + 4
res6: String = abc4

scala> 4 + "abc"
res7: String = 4abc

scala> 4 + "1.0"
res8: String = 41.0

即使上面的代码没有报错，也不能按照java的思路去理解，"abc" + 4应该理解为字符串有+(i:int)这个方法,而4 + "abc"应该理解为int有一个+(str : String)方法。

本来以为在java中会报错的，结果没有：

public class App 
{
    public static void main( String[] args )
    {
        System.out.println(4 + "abc");
        System.out.println("abc" + 4);
        System.out.println(4 + "1.0");
    }
}

scala> 4 * "abc"
<console>:12: error: overloaded method value * with alternatives:
  (x: Double)Double <and>
  (x: Float)Float <and>
  (x: Long)Long <and>
  (x: Int)Int <and>
  (x: Char)Int <and>
  (x: Short)Int <and>
  (x: Byte)Int
 cannot be applied to (String)
       4 * "abc"
         ^

Scala是强类型的，使用类型推断，并可以在编译期间进行类型检查(不需要声明变量的类型，并不代表变量是没有类型的)。

scala> var i = 1
i: Int = 1

scala> i = "abc"
<console>:12: error: type mismatch;
 found   : String("abc")
 required: Int
       i = "abc"
           ^

Scala在编译期间绑定变量类型。
i就是int类型，并且不可以改变。

5.2.2 表达式与条件

scala> 5 < 6
res10: Boolean = true

scala> 5 <= 6
res11: Boolean = true

scala> 5 <= 2
res12: Boolean = false

scala> 5 >= 2
res13: Boolean = true

scala> 5 != 2
res14: Boolean = true

if表达式

scala> val a = 1
a: Int = 1

scala> val b = 2
b: Int = 2

scala> if ( b < a) {
     |     println("true")
     | } else {
     |     println("false")
     | }
false

`var`声明不变量，`var`声明变量

空值、0不可转换为布尔值

强类型是指这门语言检查两种类型是否兼容，如果不兼容则会抛出一个错误或强制类型转换。
静态类型语言强迫在类型结构的基础上执行多态。

scala> Nil
res16: scala.collection.immutable.Nil.type = List()

scala> if (0) { println("true")}
<console>:12: error: type mismatch;
 found   : Int(0)
 required: Boolean
       if (0) { println("true")}
           ^

scala> if (Nil) {println("true")}
<console>:12: error: type mismatch;
 found   : scala.collection.immutable.Nil.type
 required: Boolean
       if (Nil) {println("true")}
           ^

java中空值、0不可转换为布尔值

Paste_Image.png

5.2.3 循环

object App {
  def whileLooop {
    var i = 1
    while (i <= 3) {
      println(i)
      i += 1
    }
  }
  def main(args: Array[String]) = {
    whileLooop
  }
}

在Scala中，public是默认的可见级别。

  def forLoop {
    var args = Array(1, 2, 4)
    println("for loop using Java-style iteration")
    for (i <- 0 until args.length) {
      println(args(i))
    }
  }
  def main(args: Array[String]) = {
    forLoop
  }



object App {

  def rubyStyleForLoop(args: Array[String]) {
    println("for loop using Ruby-style iteration")
    args.foreach { arg =>  
      println(arg)  
    }
  }
  def main(args: Array[String]) = {
    rubyStyleForLoop(Array("a", "b", "c"))
  }
}

5.2.4范围与元组

范围

scala> val range = 0 until 10
range: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> range.start
res0: Int = 0

scala> range.end
res1: Int = 10

scala> range.step
res2: Int = 1

scala> (0 to 10) by 5
res3: scala.collection.immutable.Range = Range(0, 5, 10)

scala> (0 to 10) by 6
res4: scala.collection.immutable.Range = Range(0, 6)

scala> (0 to 10 by 6)
res5: scala.collection.immutable.Range = Range(0, 6)

scala> (0 until 10 by 5)
res6: scala.collection.immutable.Range = Range(0, 5)

scala> val range = (10 until 0) by -1
range: scala.collection.immutable.Range = Range(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

scala> val range = (10 until 0 by -1)
range: scala.collection.immutable.Range = Range(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

scala> val range = 10 until 0 by -1
range: scala.collection.immutable.Range = Range(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

//方向是无法被推断出来的
scala> val range = (10 until 0)
range: scala.collection.immutable.Range = Range()

scala> val range = (0 to 10)
range: scala.collection.immutable.Range.Inclusive = Range(0, 1, 2, 3, 4, 5, 6, 7
, 8, 9, 10)

scala> val range = 'a' to 'e'
range: scala.collection.immutable.NumericRange.Inclusive[Char] = NumericRange(a,
 b, c, d, e)

begin to end包括end
begin until end不包括end

scala> 0 to 10
res0: scala.collection.immutable.Range.Inclusive = Range(0, 1, 2, 3, 4, 5, 6, 7,
 8, 9, 10)

scala> 0 until 10
res1: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

元组

元组是一个固定长度的对象集合。元组中的对象可以具有不同类型。在纯函数式编程语言中，程序员经常用元组便是对象以及它们的属性。

scala> val person = ("Elvis", "Presley")
person: (String, String) = (Elvis,Presley)

scala> person._1
res2: String = Elvis

scala> person._2
res3: String = Presley

scala> person._3
<console>:13: error: value _3 is not a member of (String, String)
       person._3

Scala使用元组而不是列表进行多值赋值

scala> val (x, y) = (1, 2)
x: Int = 1
y: Int = 2

scala> val x,y = 1,2
<console>:1: error: ';' expected but ',' found.
val x,y = 1,2
           ^

元组具有固定长度。

scala> val (a, b) = (1, 2, 4)
<console>:11: error: constructor cannot be instantiated to expected type;
 found   : (T1, T2)
 required: (Int, Int, Int)
       val (a, b) = (1, 2, 4)

5.2.5 Scala中的类

scala> class Person(firstName: String, lastName: String)
defined class Person

scala> new Person
<console>:13: error: not enough arguments for constructor Person: (firstName: St
ring, lastName: String)Person.
Unspecified value parameters firstName, lastName.
       new Person
       ^

scala> new Person("xiaoming", "huang")
res9: Person = Person@7412a438




class Compass {
  //{}内的全部内容都是构造函数的
  val directions = List("north", "east", "south", "west")
  var bearing = 0
  print("Initial bearing: ")
  println(directions)
  
  
  def direction() = directions(bearing)
  
  def inform(turnDirection: String) {
    println("Turning " + turnDirection + ". Now bearing " + direction)
  }
  
  def turnRight() {
    bearing = (bearing + 1) % directions.size
    inform("right")
  }
  
  def turnLeft() {
    bearing = (bearing + (directions.size - 1)) % directions.size
    inform("left")
    
  }
}
object App {

  
  def main(args: Array[String]) {
     val myCompass = new Compass
    
        myCompass.turnRight()
      myCompass.turnRight()
      
      myCompass.turnLeft()
      myCompass.turnLeft()
      myCompass.turnLeft()
      myCompass.turnLeft()
  }
  
}

辅助构造器



class Person(first_name: String) {
  println("Outer constructor")
  
  def this(first_name: String, last_name: String) {
    this(first_name)
    println("Inner constructor")
  }
  
  def talk() = println("Hi")
  
}
object Person{
  def main(args: Array[String]) {
    val bob = new Person("Bob")
    val bobTate = new Person("Bob", "Tate")
  }
}

5.2.6 扩展类

1.伙伴对象和类方法

object TureRing {
  def rule = println("To rule them all")
}

上面代码创建了一个单件(singleton)对象。在Scala中，对象定义和类定义可以具有相同的名称。可以在一个单件对象的声明中创建类方法而在类声明中创建实例方法。

2.继承


class Person(val name: String) {
  def talk(message: String) = println(name + " says " + message)
  def id(): String = name
}
class Employee(override val name: String, val number: Int) extends Person(name) {
  override def talk(message: String) {
    println(name + " with number " + number + " says " + message)
  }
  override def id(): String = number.toString()
}

object App{
  def main(args :Array[String]){
    val employee = new Employee("Yoda", 4)
    employee.talk("Extend or extend not. There is no try.")
  }
}

无论是在构造器中还是在任何扩展基类的方法里，override关键字都是必需的。

3. trait

一个对象可以拥有多种不同的角色。
可以将Scala的trait看成是Java的接口外加一个接口的实现。
也可以将trait看成是一个部分类的实现。

class Person(val name :String)

trait Nice {
  def greet() = println("Howdily doodily.")  
}

class Character(override val name :String) extends Person(name) with Nice

object App{
  def main(args : Array[String]){
    val flanders = new Character("Ned")
    flanders.greet
  }
}

5.2.7 第一天我们学到了什么

Scala的静态类型是可以推断出来的，用户无需在任何场合都显示声明变量的类型，因为Scala经常可以根据语法线索推断出这些类型。
编译器也可以强制类型转换，在合理的情况下，编译器还允许隐式类型转换。

Scala不支持类方法，而是使用了一种称为伙伴对象的概念将同一个类的类方法和实例方法混在一起。

5.3 第二天：修建灌木丛和其他新把戏

//单行方法定义
scala> def double(x:Int):Int = x * 2
double: (x: Int)Int

scala> double(4)
res0: Int = 8

def关键字既可以定义函数也可以定义方法。

//块形式
scala> def double(x :Int):Int = {
     |     x * 2
     | }
double: (x: Int)Int

scala> double(6)
res0: Int = 12

在返回类型Int后面的=是必需的。漏掉的话会出错。

5.3.1 对比`var`和`val`

scala> var mutable = "I am mutable"
mutable: String = I am mutable

scala> mutable = "Touch me, change me..."
mutable: String = Touch me, change me...

scala> val immutable = "I am not mutable"
immutable: String = I am not mutable

scala> immutable = "Can't touch this"
<console>:12: error: reassignment to val
       immutable = "Can't touch this"
                 ^

var变量的值是可变的，而val变量的值是不变的。
在控制台中，为方便起见，你可以多次重复定义一个变量，即使你使用的是val。一旦你脱离控制台，重定义变量会引发一个错误。
Scala引入var风格变量以支持传统的命令式编程风格，但是要避免使用var。
可变状态限制并发。

5.3.2 集合

函数式编程语言因其甚为好用的集合操作而闻名已久。

列表

scala> List(1, 2, 3)
res1: List[Int] = List(1, 2, 3)

scala> List("one", "tow", "three")
res2: List[String] = List(one, tow, three)

scala> List("one", "tow", 3)
res3: List[Any] = List(one, tow, 3)

scala> List("one", "tow", 3)(2)
res4: Any = 3

scala> List("one", "tow", 3)(4)
java.lang.IndexOutOfBoundsException: 4
  at scala.collection.LinearSeqOptimized$class.apply(LinearSeqOptimized.scala:65
)
  at scala.collection.immutable.List.apply(List.scala:84)
  ... 32 elided

列表访问是一个函数，所以使用的是()而不是[]。

scala> List("one", "tow", 3)(-1)
java.lang.IndexOutOfBoundsException: -1
  at scala.collection.LinearSeqOptimized$class.apply(LinearSeqOptimized.scala:65
)
  at scala.collection.immutable.List.apply(List.scala:84)
  ... 32 elided

scala> List("one", "tow", 3)(-2)
java.lang.IndexOutOfBoundsException: -2
  at scala.collection.LinearSeqOptimized$class.apply(LinearSeqOptimized.scala:65
)
  at scala.collection.immutable.List.apply(List.scala:84)
  ... 32 elided

scala> List("one", "tow", 3)(-3)
java.lang.IndexOutOfBoundsException: -3
  at scala.collection.LinearSeqOptimized$class.apply(LinearSeqOptimized.scala:65
)
  at scala.collection.immutable.List.apply(List.scala:84)
  ... 32 elided

用负数作为下标，早期的Scala版本会返回列表的第一个元素。但是这种行为与表示下标值过大的异常NoSuchElement不一致，所以2.8.0版本修改了这种行为，让它返回java.lang.IndexOutOfBoundsException异常。
Nil是一个空列表。

scala> Nil
res9: scala.collection.immutable.Nil.type = List()

2.集

scala> val animals = Set("lions", "tigers", "bears")
animals: scala.collection.immutable.Set[String] = Set(lions, tigers, bears)

scala> animals + "armadillos"
res10: scala.collection.immutable.Set[String] = Set(lions, tigers, bears, armadillos)

scala> animals - "tigers"
res11: scala.collection.immutable.Set[String] = Set(lions, bears)

scala> animals + Set("armadillos", "raccoons")
<console>:13: error: type mismatch;
 found   : scala.collection.immutable.Set[String]
 required: String
       animals + Set("armadillos", "raccoons")
                    ^

集操作是没有破坏性的。每个集操作都会建立一个新的集而不是修改旧的集。默认情况下，集是不可改变的。

scala> animals ++ Set("armadillos", "raccoons")
res13: scala.collection.immutable.Set[String] = Set(bears, tigers, lions, armadillos, raccoons)

scala> animals -- Set("lions", "bears")
res14: scala.collection.immutable.Set[String] = Set(tigers)

交集

scala> animals & Set("armadillos", "raccoons", "lions", "tigers")
res16: scala.collection.immutable.Set[String] = Set(lions, tigers)

与列表不同，集与次序无关。

scala> Set(1, 2, 3) == Set(3, 2, 1)
res17: Boolean = true

scala> List(1, 2, 3) == List(3, 2, 1)
res18: Boolean = false

映射

scala> val ordinals = Map(0 -> "zero", 1 -> "one", 2 -> "tow")
ordinals: scala.collection.immutable.Map[Int,String] = Map(0 -> zero, 1 -> one,
2 -> tow)

scala> ordinals(2)
res19: String = tow

scala> import scala.collection.mutable.HashMap
import scala.collection.mutable.HashMap

scala> val map = new HashMap[Int, String]
map: scala.collection.mutable.HashMap[Int,String] = Map()

scala> map += 4 -> "four"
res20: map.type = Map(4 -> four)

scala> map += 8 -> "eight"
res21: map.type = Map(8 -> eight, 4 -> four)

scala> map
res22: scala.collection.mutable.HashMap[Int,String] = Map(8 -> eight, 4 -> four)

scala> map += "zeor" -> 0
<console>:14: error: type mismatch;
 found   : (String, Int)
 required: (Int, String)
       map += "zeor" -> 0
                     ^

4.Any和Nothing

所有类都继承自Any,并且Nothing类继承自所有类。

Any和Nothing

5.3.3 集合与函数

高阶函数：一个以其他函数作为输入参数或以函数作为返回结果的函数。

1.foreach

//代码块
variableName => yourCode

scala>  val list = List("frodo", "samwise", "pippin")
list: List[String] = List(frodo, samwise, pippin)

scala> list.foreach(hobbit => println(hobbit))
frodo
samwise
pippin

scala> val hobbits = Set("frodo", "samwise", "pippin")
hobbits: scala.collection.immutable.Set[String] = Set(frodo, samwise, pippin)

scala> hobbits.foreach(hobbit => println(hobbit))
frodo
samwise
pippin

scala> val hobbits = Map("frodo" -> "hobbit", "samwise" -> "hobbit", "pippin" ->
 "hobbit")
hobbits: scala.collection.immutable.Map[String,String] = Map(frodo -> hobbit, sa
mwise -> hobbit, pippin -> hobbit)

scala> hobbits.foreach(hobbit => println(hobbit))
(frodo,hobbit)
(samwise,hobbit)
(pippin,hobbit)

scala> hobbits.foreach(hobbit => println(hobbit._1))
frodo
samwise
pippin

scala> hobbits.foreach(hobbit => println(hobbit._2))
hobbit
hobbit
hobbit

2.更多列表方法

scala> list
res5: List[String] = List(frodo, samwise, pippin)

scala> list.isEmpty
res6: Boolean = false

scala> Nil.isEmpty
res7: Boolean = true

scala> list.length
res8: Int = 3

scala> list.size
res9: Int = 3

获取列表的头和尾对递归非常有用。

scala> list.head
res10: String = frodo

scala> list.tail
res11: List[String] = List(samwise, pippin)

scala> list.last
res12: String = pippin

scala> list.init
res13: List[String] = List(frodo, samwise)

scala> list
res14: List[String] = List(frodo, samwise, pippin)

scala> list.reverse
res15: List[String] = List(pippin, samwise, frodo)

scala> list.drop(1)
res16: List[String] = List(samwise, pippin)

scala> list
res17: List[String] = List(frodo, samwise, pippin)

scala> list.drop(2)
res18: List[String] = List(pippin)

3.计数、映射、过滤以及其他

scala> val words = List("peg", "al", "bud", "kelly")
words: List[String] = List(peg, al, bud, kelly)

scala> words.count(word => word.size > 2)
res19: Int = 3

scala> words.filter(word => word.size > 2)
res20: List[String] = List(peg, bud, kelly)

scala> words.map(word => word.size)
res21: List[Int] = List(3, 2, 3, 5)

scala> words.forall(word => word.size > 1)
res22: Boolean = true

scala> words.exists(word => word.size > 4)
res23: Boolean = true

scala> words.exists(word => word.size > 5)
res24: Boolean = false

scala> words.sortWith((s, t) => s.size < t.size)
res32: List[String] = List(al, peg, bud, kelly)

4. foldLeft

floadLeft会将数组中的每个元素和另外的一个值传递给代码块。另外的值可以是初始值（在第一次调用代码块时）也可以是从代码块中返回的结果。

initialValue /: List codeBlock

scala> words.sortWith((s, t) => s.charAt(0).toLower < t.charAt(0).toLower)
res34: List[String] = List(al, bud, kelly, peg)

scala> val sum = (0 /: list) {(sum, i) => sum + i}
sum: Int = 6

柯里化

函数式编程语言使用柯里化将一个带有多个参数的函数转换为多个拥有独立参数列表的函数。

scala> val list = List(1, 2, 3)
list: List[Int] = List(1, 2, 3)

scala> list.foldLeft(0)((sum, value) => sum + value)
res35: Int = 6

5.3.4 第二天我们都学到了什么

编译器尝尝能推断出函数的返回类型，函数定义有单行和代码块两种形式，并且参数列表可以改变。。

5.4 第三天：剪断绒毛

5.4.1 XML

Scala将XML抬高到语言的一等编程结构。

scala> var movies =
     | <movies>
     |     <movie genre="action">Pirates of the Caribbean</movie>
     |     <movie genre="fairytale">Edward Scissorhands</movie>
     | </movies>
movies: scala.xml.Elem =
<movies>
    <movie genre="action">Pirates of the Caribbean</movie>
    <movie genre="fairytale">Edward Scissorhands</movie>
</movies>

scala> movies.text
res36: String =
"
    Pirates of the Caribbean
    Edward Scissorhands
"

Scala内置了一种与XPath类似的查询语言，XPath是一种XML查询语言。不过由于在Scala中，关键字//是注释的修饰符，Scala将使用\和\\。

scala> val movieNodes = movies \ "movie"
movieNodes: scala.xml.NodeSeq = NodeSeq(<movie genre="action">Pirates of the Caribbean</movie>, <movie genre="fairytale">Edward Scissorhands</movie>)

scala> val movieNodes = movies \\ "movie"
movieNodes: scala.xml.NodeSeq = NodeSeq(<movie genre="action">Pirates of the Caribbean</movie>, <movie genre="fairytale">Edward Scissorhands</movie>)

scala> movieNodes(0)
res37: scala.xml.Node = <movie genre="action">Pirates of the Caribbean</movie>

scala> movieNodes(0) \ "@genre"
res38: scala.xml.NodeSeq = action

5.4.2 模式匹配


object App{
  def doChore(chore: String): String = chore match {
    case "clean dishes" => "scrub, dry"
    case "cook dinner" => "chop, sizzle"
    case _ => "whine, complain"//_是一个通配符
  }
  def main(args : Array[String]){
      println(doChore("clean dishes"))
    println(doChore("mow lawn"))
  }
}

1.哨兵


object App{
  def factorial(n: Int): Int= n match {
    case 0 => 1
    case x if x > 0 => factorial(n - 1) * n
  }
  def main(args : Array[String]){
      println(factorial(3))
      println(factorial(0))
  }
}

2.正则表达式

Scala中的正则表达式是一等类型。针对一个字符串的.r方法可以将任意字符串转换成正则表达式。

scala> val reg = """^(F|f)\w*""".r
reg: scala.util.matching.Regex = ^(F|f)\w*

scala> println(reg.findFirstIn("Fantastic"))
Some(Fantastic)

scala> println(reg.findFirstIn("not Fantastic"))
None

用"""为字符串划定界限，允许多行字符串，去除了其内部字符串的求职过程。.r方法将字符串转换为正则表达式。

scala> val reg = "the".r
reg: scala.util.matching.Regex = the

scala> reg.findAllIn("the way the scissors trim the hair and the shrubs")
res41: scala.util.matching.Regex.MatchIterator = non-empty iterator

scala> val matchs = reg.findAllIn("the way the scissors trim the hair and the shrubs")
matchs: scala.util.matching.Regex.MatchIterator = non-empty iterator

scala> matchs.foreach(it => println(it))
the
the
the
the

3.XML和匹配

import scala.xml
  
object App{
  def main(args : Array[String]){
    val movies = <movies>
            <movie>The Incredibles</movie>
            <movie>WALL E</movie>
            <short>Jack Jack Attack</short>
        <short>Geri's Game</short>
    </movies>
    (movies \ "_").foreach{ movie => 
      movie match {
        case <movie>{movieName}</movie> => println(movieName)
        case <short>{shortName}</short> => println(shortName + "(short)" )
      }    
    }
  }
}

5.4.3 并发

包括actor和消息传递。actor拥有线程池和队列池。当发送一条消息给actor时（使用!操作符）,是将一个对象放到该actor的队列中。actor读取消息并采取行动。通常情况下，actor通过模式匹配器去检测消息并执行相应的消息处理。

import scala.actors.Actor

case object Poke
case object Feed

class Kid() extends Actor {
  def act() = {
    loop {
      react {
        case Poke => {
            println("Ow...")
            Thread.sleep(2000)
          println("Quit it...")
        }
        case Feed => {
            println("Gurgle...")
            Thread.sleep(2000)
          println("Burp...")
        }
      }
    }
  }
}
object App {
  def main(args: Array[String]) {
      val bart = new Kid().start
    val lisa = new Kid().start
    bart ! Poke
    lisa ! Poke
    bart ! Feed
    lisa ! Feed
  }
}

Kid是actor，这意味着它将在线程池中的某个线程中运行，并从一个队列中读取消息。它将一个接一个地处理每条消息。react可以接收来自actor的消息。

使用actor，可以设置超时处理(reactWithin),当在指定时间内没有接收到消息时，会触发超时处理。使用receive（它将阻塞线程）和receiveWithin(它将在设置的超时时间内阻塞线程)。

5.4.4 实际中的并发

import scala.io._
import scala.actors._
import Actor._

object App {
  object PageLoader {
    def getPageSize(url: String) = Source.fromURL(url).mkString.length
  }
  val urls = List("http://www.baidu.com/",
                  "http://www.jianshu.com/",
                  "http://www.youdao.com/",
                  "http://www.sina.com.cn/")
  def timeMethod(method: ()=> Unit) = {
    val start = System.nanoTime()
    method()
    val end = System.nanoTime()
    println("Method took " + (end - start)/1000000000.0 + " seconds." )
  }
  
  def getPageSizeSequentially() = {
    for (url <- urls) {
      println("Size for " + url + ":" + PageLoader.getPageSize(url))
    }
  }
  
  def getPageSizeConcurrently() = {
    val caller = self
    
    for (url <- urls) {
      actor { caller !(url, PageLoader.getPageSize(url))}
    }
    
    for (i <- 1 to urls.size) {
      receive {
        case (url, size) => 
          println("Size for " + url + ": " + size)
      }
    }
  }
  def main(args: Array[String]) {
      println("Sequential run:")
      timeMethod{getPageSizeSequentially}
      
    println("Concurrent run:")
    timeMethod{getPageSizeSequentially}
    
    
  }
}

5.4.5 第三天我们学到了什么

actor是为并发而构建出来的对象。通常拥有一个包含react或receive方法的循环，用于接收发给该对象的队列消息。

5.5 趁热打铁

Scala使用的是静态类型策略。

5.5.1核心优势

1.并发

无需可变状态的并发应用设计能力
不变性是为改善并发代码设计能够做的唯一的、最重要的事情。

2. 遗留Java的演化

Scala应用可以直接使用Java库，并且在必要时可以使用代理对象的代码生成功能，与Java的互操作行非常好。
创立新的编程社区的最好方法就是充分接受现有的社区。
代码块成为了语言的一等类型构造，并且可以与核心集合库很好地集成在一起使用。

3. 领域特定语言

Scala灵活语法和操作符重载
操作符只是简单的方法声明

4.XML

Scala提供内置的XML支持。模式匹配使得各种不同的XML结构的解析块易于使用。将XPath语法集成到复杂的XML中使得代码变得更为简单、可读。

5.桥接

函数式编程模式很重要，因为它可以很好地处理并发，并且处理器的并发程度也越来越高。

5.5.2 不足之处

Scala的语法要求过多且偏学术性。

1. 静态类型

静态类型天生适合函数式编程语言，但是对于面向对象系统就是灾难

2.语法

构造器 new Person而不是Person.new
参数类型setName(name: String)而不是setName(String name)
返回类型从Java方法声明的开头处挪到了结尾处。

3. 可变性

可变性可能导致各种各样的并发bug。

5.5.3 最后思考

最后编辑于：2017.12.03 10:28:42

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,324评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,303评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,192评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,555评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,569评论 5赞 365
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,566评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,927评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,583评论 0赞 257
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,827评论 1赞 297
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,590评论 2赞 320
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,669评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,365评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,941评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,928评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,159评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,880评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,399评论 2赞 342

《七周七语言：理解多种编程范型 第5章 Scala》笔记