《快学Scala》学习笔记

def box(s: String) {
    var border = "-"*s.length+"--\n"
    println(border +"|"+s+"|\n"+border)
}
//如果不喜欢简明的写法，可以变成
def box(s:String): Unit={  
...
}

//在words被定义时即被取值
val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
//在words被首次使用时取值
lazy val words = scala.io.Source.fromFile("/user/share/dict/words").mkString
//在每一次words被使用时取值
def words = scala.io.Source.fromFile("/user/share/dict/words").mkString

val a = Array(1,2,3,11)
val result = for (elem <- a if elem%2 == 0) yield 2*elem

a.filter(_%2==0).map(2*_)
//结果完全相同，只是实现的风格不同

val triangle = new Array[Array[Int]](10)
for(i <- until triangle.length)
    triangle(i) = new Array[Int](i+1)

//构造不可变Map[String,Int]
val scores = Map("alice"->10,"bob"->3)
//可变Map
val scores = scala.collection.mutable.Map("alice"->10,"bob"->3)
//空映射
val scores = new scala.collection.mutable.HashMap

//不存在键则会抛出异常
val bobscore = scores("bob")
//默认值
scores.getOrElse("bob",0)
//返回Option 要么Some类型（键对应的值），要么None
scores.get("bob")

//更新或者增加
scores("bob") = 10
//批量操作
scores += ("bob" -> 10,"fred"->7)
//移除某个键
scores -= "bob"

val newScores = scores + ("bob" -> 10,"fred"->7)

val t = (1,3.14,"fred")
//可以用 _1,_2,_3这种方式访问
val second = t._2
//匹配模式 获取
val (first, second, _) = t

//scala中每个NetWork实例都有她自己的Member类
class NetWork {
   class Member(val name:String){
    val contacts = new ArrayBuffer[Member]
   }
   
   private val members = new ArrayBuffer[Member]
   
   def join(name:String) = {
        val m = new Member(name)
        members += m
        m
   }
}

//调用的是apply(100),输出一个单元素（整数100）的Array[Int];
Array(100) 
//调用构造器this(100),结果是Array[Nothing],包含了100个null元素
new Array(100)

package  com {
    package horstmann{
        package impatient {
            class Employee
              ...
        }
    }
}

package org{
    package bigjava{
        class Counter
          ...
    }
}

package com.horstmann.impatient
package people
class  Person
...

package com.horsmann.impatient{
    package people{
        class Person
          ...
    }
}

class Manager{
    jimport scala.collection.mutable._
    val subordinates = new ArrayBuffer[Emplyee]
}

//部分引用 选取器
import java.awt.{Color,Font}
//重命名
import java.util.{HashMap => JavaHashMap}

//这种引用被允许可以覆盖之前的引用
import java.lang._
import scala._
import Predef._

if (p.isInstanceOf[Employye]){
    val s = p.asInstanceOf[Employee]
      ...
}

if (p.getClass == classOf[Employee])

//scala写法
class Employee(name:String,age:Int,val salary:Double) extends Person(name,age)
//等同于java写法
public class Employee extends Person {
    private double salary;
    public Employee(String name,int age,double salary){
        super(name,age);
        this.salary = salary;
    }
}

trait Logger {
    def log(msg:String)
}
class ConsoleLogger extends Logger{ 
    //不需要写override
    def log(msg: String){
        println(msg)
    }
}

//如果特质混入另一个特质，其中抽象方法log,需要调用super.log 则需要标记。
trait TimestampLogger extends Logger {
    abstract override def log(msg: String){
        super.log(new java.util.Date() + "" + msg)
    }
}

trait Logged{
    //log 什么也没做
    def log(msg:String){
    
    }
}

//现在 SavingsAccount 什么都不会被记录到日志中，看上去似乎毫无意义
//但是你可以在构造具体对象的时候“混入”一个更好的日志记录器的实现。
class SavingsAccount extends Account with Logged{
    def withdraw(amount:Double){
        if(amount > balance) log("Insufficient funds")
        else   ...
    }
}

trait ConsoleLogger extends Logged{
    override def log(msg :String){
        println(msg)
    }
}

//你可以再构造对象的时候加入特质
val acct = new SavingsAccount with ConsoleLogger
//另一个对象可以加入不同的特质
val acct2 = new SavingsAccount with FileLogger

trait ShortLogger extends Logged{
    val maxLength = 15 //具体字段
}

class Account {
    var balance = 0.0
}

class SavingsAccount extends Account with ConsoleLogger with ShortLogger {
    var interest = 0.0
    def withdraw(amount:Double){
        if(amount >balance) log("Insufficeent funds")
        else   ...
    }
}

//其中子类字段 interest , maxLength
// 超类字段 balance

class SavingsAccount extends Account with FileLogger with ShortLogger

如果C extends C1 with C2 with ...with Cn 则 linc(C) = C>> lin(Cn) >> ...>>lin(C2) >> lin(C1)

lin(SavingsAccount) = SavingsAccount >> lin(ShortLogger) >> lin(FileLogger) >> lin(Account)
                    = SavingsAccount >> (ShortLogger >> Logger) >> (FileLogger >> Logger) >> lin(Account)
                    = SavingsAccount >> ShortLogger >> FileLogger >> Logger >> Account
                    (省略了线性化末端类型：ScalaObject、AnyRef、Any)

trait LoggedException extends Exception with Logged{
    def log(){
        log(getMessage())
    }
}

// 没有扩展Exception类，但是有个自身类型Exception. 意味着，它只能混入Excetpion的子类。
trait LoggedException extends Logged {
    this: Exception => def log() {log(getMessage())}
}

//自身类型也同样可以处理结构类型（structural type） 这种类型只给出类必须拥有的方法，而不是类的名称。
trait LoggedException extends Logged{
    this: {
        def getMessage(): String
    } => def log(){
        log(getMessage())
    }
}

def mulBy(factor:Double) = (x:Double) => factor * x
val triple = mulBy(3)
val half = mulBy(0.5)
//单一你 42  7 
//每一个返回的函数都有自己的factor设置
println(triple(14) + "" + half(14))

def mulOneAtATime(x:Int) = (y: Int) => x * y
//简写
def mulOneAtATime(x: Int) (y: Int) = x * y

val digits = List(4,2)
// digits.head的值是4，而digits.tail是List(2)。再进一步 digits.tail.head是2，而digits.tail.tail是Nil

//::操作符 从给定的头和尾创建一个新的列表。
9 :: List(4,2)
9 :: 4 :: 2 :: Nil

def numsFrom(n: BigInt): Stream[BigInt] = n #:: numsFrom(n+1)
// #:: 操作符构建出来的是一个流
val squares = numsFrom(1).map(x => x * x)
//将产出 stream(1,?)
//如果你想得到多个答案，则可以调用take，然后用force，这将强制对所有值求值。
squares.take(5).force
//将产生Stream(1,4,9,16,25)

val powers = (0 until 1000).view.map(pow(10,_))

SynchronizedBuffer
SynchronizedMap
SynchronizedPriorityQueue
SynchronizedQueue
SynchronizedSet
SynchronizedStack

obj match{
    case x: Int => x
    case s: String => Integer.parseInt(s)
    case _: BigInt => Int.MaxValue
    case _  => 0
}

//别这样做
case m: Map[String,Int] => ...

//可以匹配一个通用映射
case m: Map[_,_] => ...

//但是，对于数组而言元素的类型信息是完好的。你可以匹配到Array[Int]

for((k,v) <- System.getProperties())
    println(k +" -> " +v)

// for 推导式中，失败的匹配将被安静的忽略
//如下循环将打印出所有值为空白的键，跳过所有其他的键
for((k,"") <- System.getProperties())
    println(k)

abstract class Amount

case class Doller(value: Double) extends Amount
case class Currency(value: Double, unit: String) extends Amount

//我们可以用模式匹配来匹配到它的类型，并将属性值绑定到变量:
amt match {
    case Dollar(v) => "$" + v
    case Currency(_,u) => "Oh noes, I got " + u
    case Nothing => ""
}

val f: PartialFunction[Char,Int] = { case '+' => 1; case '-' => -1}
f('-') // 返回-1 调用f.apply('-')
f.isDefinedAt('0') //false
f('0') //抛出MatchError

object Util{
   @tailrec def sum(xs: Seq[Int],partial:BigInt): BigInt = if(xs.isEmpty) partial else sum2(sx.tail, xs.head + partial) 
}

import scala.util.control.TailCalls._
def evenLength(sx:Seq[Int]): TailRec[Boolean] = 
    if (xs.isEmpty) done(true) else tailcall(oddLength(sx.tail))

def oddLength(xs: Seq[Int]): TailRec[Boolean] = 
    if (xs.isEmpty) done(false) else tailcall(evenLength(xs.tail))

//顶一个一个带有两个类型参数T和S的类。 在类的定义中，你可以用类型参数来定义变量、方法参数、以及返回值的类型。
calss Pair[T,S] (val first: T, val second: S)

def getMiddle[T](a:Array[T]) = a(a.length/2)

// T是 R的子类 上界
T <: R 

// T 是R的超类 下界
T :> R

calss Pair[T <: Comparable[T]]

class Pair[T <% Comparable[T]]