scala

script
-------------
    文本文件存放源代码，不需要编译，解释执行。
    javascript
    shell
    python

scala
-------------
    java语句脚本化。 
    2.11

sql
javascript
python
vbscript
shell

安装scala
-------------
    1.下载scala-2.11.8.msi
    2.安装
        C:myprogramsscala.2.11

    3.自动配置环境变量
        
    4.启动scala
        binscala.bat
        scala>

REPL
--------------
    read -> evaluate -> print -> loop

    类型推断

scala基本语法
----------------
    val    x = 10                        //常量,类型推断得到
    var    x = 10                        //变量

    1 + 1                            //操作符
    1.+(1)                            //操作符重载

    1 to 10                            //构造 1 ,2,3,4 .. 10序列
    "hello ".toUpperCase()            //字符串方法
    val x:Int = 10                    //声明类型

    [scala常用类型]
    java                scala
    --------------------------
    byte                Byte
    short                Short
    int                    Int                
    long                Long
    char                Char
    float                Float
    double                Double

    val x:BigInt = 123456789        //
    x * x * x * x * x * x * x * x    //大数运算

    //函数:直接调用的
    import scala.math._                //import math._
    sqrt(2)                            //开方函数
    pow(3,2)                        //幂函数

    //方法:通过对象调用的是方法。

    "hello world"(0)                //"hello".apply(4)
    BigInt("12345")                    //BigInt.apply(123)

scala控制语句
-----------------
    scala任何代码块都有返回值，最后一条语句就是返回值。
    val y = if(x > 0) 1 else -1
    //scala没有三元运算符
    val y = x > 0 ? 1 : -1            //wrong

    //Unit类型，表示()
    val:Unit = ()

    //scala没有switch语句。

    //{}的用法
    val y = if (x > 0) 1 else {
        -1
        }

    //粘贴模式
    :paste
    ...
    ctrl +d                    //结束


    //
    var x =100 ; x  =1000    //使用;表示终止

    //打印输出
    print("hello")
    println("hello")
    printf("%s=%d
" , "tom" ,12)


    //读取控制台输入
    readLine("your name is : ")
    
    //while循环,scala没有i ++
    var n = 0 ;
    while(n < 10){
        n = n + 1
        println(n)    
    }

    
    //for循环
    for(x <- 1 to 10) println(x)

    var sum = 0 
    for(x <- 1 to 10) sum += x

    //until[1,10)
    val x = 1 until 10

    //while循环打印99表格
var row = 1 ;
while(row <= 9){
var col = 1 ;
while(col <=row){
printf("%dx%d=%d	" , col , row , col * row)
col += 1
}
println()
row += 1
}

    //for循环打印99表格
    for(x <- 1 to 9){
        for(y <- 1 to x){
            printf("%dx%d=%d	" , y , x , x * y)
        }
        println()
    }

    //scala没有break和continue
    import util.control.Breaks._
    for(x <- 1 to 10){println(x) ; break()}

    //for高级推导式,类似于双循环嵌套,
    for(x <- 1 to 3 ; y <- 4 to 6)println(x * y)

    //守卫条件
    for(x <- 1 to 5 ; y <- 4 to 6 if x == y)println(x * y)

    //yield产生新集合
    for(x <- 1 to 10 ) yield x * 2

    //函数
    def add(x:Int , y:Int):Int = x + y
    add(1,2)                                                //调用函数

    //递归函数必须声明返回值类型
    def fac(n:Int):Int = if(n == 1) 1 else n * fac(n-1)        //递归函数

    //默认参数和带名参数
    def decorate(pre:String = "<<<",str:String,suf:String=">>>") = pre+str+suf
    decorate("<<<","hello",">>>")
    decorate(str="hello" , pre="<<<",suf=">>>")                //

    //变长参数

    def sum(args:Int*) = {
        var sum =0  
        for(x <- args) sum += x 
        sum
    }

    sum(1 to 10:_*)        
    
    //过程，函数中没有=,返回值Unit, 表示()
    def out(){println("hello world")}
    out                                                    //ok,调用
    out()                                                //ok

    //lazy,延迟计算。
    var x = 1    + 1
    lazy val x = 1    + 1                                    //<lazy>



scala中"_"用法
----------------
    1.导包
        import math._                //统配

    2.1 to 10转序列
        1 to 10:_*            


作业
------------
    scala实现百钱买白鸡问题!
    100块钱买100只鸡.
    公鸡: 5元/只
    母鸡: 3元/只
    小鸡: 1元/3只
var x = 0
var y = 0     //三层for循环
var z = 0
for(x <- 0 to  20){
for(y<- 0 to 33){
for(z<- 0 to (100-x-y)){
if(z%3==0){
if(x*5+y*3+z/3==100){
if(x+z+y==100){
println("公鸡:"+x+"母鸡:"+y+"小鸡:"+z)
}
} 
}
}
}
}

for(x<- 0 to 20 ; y<- 0 to 30 ; z<- 0 to (100-x-y) if(z%3==0) if(x+z+y==100) if(x*5+y*3+z/3==100))println("公鸡:"+x+"母鸡:"+y+"小鸡:"+z)




//************************************************8

scala
------------
    java脚本化。
    函数式编程。
    开发效率高
    procedure        //def xx(){}
    function        //def xxx() = {}
    类型推断
    val                //常量
    var                //变量

while(){
}

for(x <- 1 to 10 if ..){
    println(x) ;
}

数组
---------------
    //创建数组,长度10，Int是泛型。
    val arr = new Array[Int](10)

    //快速构建数组
    val arr = Array(1,2,3)
    val arr = Array.apply(1,2,3)

    val arr = new Array[Int](3)
    //访问特定元素，下标值
    arr(0) = 1
    arr(1) = 2
    arr(2) = 3

    //
    val arr = Array[Int](3)
    val arr = new Array[Int](3)

变长数组(缓冲区)
--------------
    import scala.collection.mutable.ArrayBuffer
    val buf = ArrayBuffer(1,2,3)
    val buf = ArrayBuffer[Int]()

    //=对自身的内容进行改变
    buf.+=(1,2,3)

    //++不改变自身，生成新对象,操纵集合
    buf.++(1 to 10)

    //++/--通常是操纵集合元素

    //移除最后的n个元素,修改自身
    buf.trimEnd(3)

    //insert,在指定索引位置插入元素
    buf.insert(n:Int , seq:Int*)
    buf.insert(0,1)
    buf.insert(0,2,3,4)

    //从指定位置开始移除多少元素
    buf.remove(0,2)                        //移除开始的两个元素
    buf.remove(0)                        //移除第一个元素

    
    //遍历数组
    for(x <- buf) println(x)

    for(i <- 0 until buf.size) println(buf(0))

    //反转元素位置,10 ...1
    val x = (1 to 10).reverse

    
    //yield生成新集合
    for(x <- buf) yield x / 2

    //常用函数
    buf.sum
    buf.max
    buf.min

    //快速排序数组
    val a = buf.toArray
    scala.util.Sorting.quickSort(a)

    //数组转换String
    buf.mkString(",")
    buf.mkString("[",",","]")            //修饰符，前缀，后缀，连接符。

多维数组
-----------
    val arr = Array[Int]()
    val arr = Array[Array[Int]]()

    val arr = Array[Array[Int]](Array(1),Array(1,2),Array(1,2,3))

    for(x <- arr){
        for(y <- x){
            print(y)
        }
        println()
    }

    //构造多维数组
    val ma = Array.ofDim[Int](3,4)        //
    ma(0)(1) = 5                        //访问数组元素


和java集合的互操作
---------------------
    //自动将java的list转换成scala buffer
    def f1(list:java.util.List[String]) = println(list.size())
    val alist = new java.util.ArrayList[String]()
    alist.add("tom1")
    alist.add("tom2")
    alist.add("tom3")
    f1(alist)                //3

    f1(buf)                    //wrong

    //自动把Scala的buffer转换成java的list
    def f2(buf:Buffer[String])= println(buf.size)
    import scala.collection.JavaConversions.bufferAsJavaList
    f1(buf)                    //ok


映射和元组
----------------------
    1.映射
        Map,是对偶的集合。
        val m = Map(1->"tom",2->"tomas")
        val m = Map((1 , "tom"),(2,"tomas"),(3,"tomasLee"))
        m(1)                //m.apply(1)
        m(1) = "jerry"        //可以修改

        for((k,v) <- m) println(k + "==>" + v)        //迭代元组

    2.元组
        n个信息的组成，等价一个记录。
        类型可以不同。
        val t = (1,"tom",12) ;
        val t = new Tuple3[Int,String,Int](1,"tom",12)
        t._1
        t._2
        t._3                //元组内容不能修改。

    3.对偶
        特殊的元组，只有两个元素。
        val couple = (1,"tom")
        val couple = 1 -> "tom"
        val couple:Tuple2[Int,String] = 1 -> "tom"

    4.map和java Map互操作
        import scala.collection.JavaConversions.mapAsJavaMap
        import scala.collection.JavaConversions.propertiesAsScalaMap
    
    5.拉链操作
        将两个数组的元素一一组合，形成对偶的集合
        val ids = Array(1,2,3)
        val names = Array("tom1", "tom2" ,"tom3")
        ids.zip(names)

        //如果两边元素个数不同,-1:左侧集合的占位，nobody是右侧集合的占位。
        ids.zipAll(names,-1,"nobody")

        //zipWithIndex 元素和自己的索引构成couple
        names.zipWithIndex()

scala类
--------------
    //定义类
    class Dog{
        private var age:Int = 0 
        def incre() = age += 1
        def old() = age 
    }

    //实例化对象
    val d = new Dog
    d.<tab>

    class Dog{
        var age:Int = 0 ;
        def incre() = {age += 1};
        def old() = {age} ;
    }

    val d = new Dog()
    //get
    d.age
    //set
    d.age = 11

scala字段生成方法的原则:
-------------------------
    1.字段private，get/set也是私有的
    2.字段是val,只有get
    3.如果不需要任何get/set,可以定位private[this]


scala的private[this]
-------------------------
    只能在自己的对象中访问。
    class Dog{
    private[this] var age:Int = 0 ;
    def setAge(n:Int) = {this.age = n} ;
    def getAge() = this.age ;

    //实现标注的get/set方法
    @scala.beans.BeanProperty
    var coler:String = "yellow"
    
    //错误的，因为age是private[this]
    def compare(d:Dog)={
      this.age > d.age            
    }
    }

辅助构造器
-----------------------
    //主构造(name:String,age:Int)
    class Dog(name:String,age:Int,color:String , owner:String){
        //辅助构造
        def this()={
            this("yellow" , 12)

        }

        def who() = owner ;
    }

    1.var生成get、set方法
    2.val只对应get方法
    3.缺失var和val，如果不参与计算，不会生成任何成员
    4.缺失var和val，如果参与计算，升格为字段.


对象(单例对象)
-----------------------
    scala没有静态之说，通过object进行实现。
    object中定义的成员都是静态的。

    //内部使用java的单例设计模式实现
    Object Benz{
        val brand:String= "BENZ"
    }
    //访问静态成员
    Benz.brand

伴生对象
----------------------
    和类同名的对象就是类的伴生对象。
    class Benz{
      var color : String = "black"
    }

    object benz{
      val brand:String = "BENZ" 
    }

编写能执行scala程序
--------------------
    //编写scala入口类
    [app.scala]
    object App{
      def main(args:Array[String]) = {
        println("hello world")
      }
    }
    //编译
    scalac app.scala
    //执行
    scala app
    //直接执行scala源代码
    scala app.scala

idea安装scala插件
------------------
    1.下载scala-intellij-bin for 2016.3.6.zip
    2.settings ->plugins -> install plugin from disk ... ->定位到zip文件 ->install
    3.重启idea即可.
    4.验证


trait
-------------------
    等价于java的接口。
    scala对应第一个接口使用extends关键在，其他接口使用with
    trait USB1{
        def slot1() ;
    }

    trait USB2{
        def slot2() ;
    }

    trait USB3{
        def slot3() ;
    }


    class Mp3 extends USB1 with USB2 with USB3{
        override def slot(): Unit = {
            printf("~~~")
        }

        override def slot2(): Unit = {

        }

        override def slot3(): Unit = {
            
        }
    }

apply方法
-----------------
    apply方法定义在object中，为了快速构造对象.
    /**
      * Created by Administrator on 2018/2/9.
      */
    class Dog(var name:String,var age :Int) {

    }

    object Dog{
        def apply(n:String,age:Int) = new Dog(n,age)
    }


    val d = new Dog("tom",12)
    val d = Dog("tom",12)
    val d = Dog.apply("tom",12)


scala包和导入
--------------------
    1.定义包
        //嵌套定义
        package com{
            packate xxxx ;
        }

        //串联定义
        package com.xxx.
    
    2.别名
        import java.util.{List => juList}
        val l:juList[String ] = new java.util.ArrayList[String]()


构造父类对象
--------------------
    //主构造
    class Dog(var name:String,var age :Int) {
    }

    //继承,
    class Jing8(var n:String , var a:Int , var color:String) extends Dog(n,a){

    }

    //抽象类
    abstract class Aniaml{
        //抽象方法
        def cry() ;
        //抽象字段
        var age:Int

    }

scala类层级关系
---------------------
    Any
     ^
     |
     ---class AnyVal
     |            ^
     |            |---- Byte
     |            |---- Int
     |            |---- Short
     |            |---- ...
     |            |---- Unit
     |
     |
     ---class AnyRef
                ^         
                |---- Java Class
                |---- Scala class 
     
     ---class Nothing
     ---class Null


Null和null
-------------------------------------
    Null是类型，null是该类型唯一的一个值.
    null不可以给anyValue类型变量赋值，可以给
    AnyRef赋值。

    val x : Null = null ;

Nothing
-------------------------------------
    是类型，并且没有实例。常用于集合的泛型。
    case object Nil extends List[Nothing]
    Nil表示空集合。
    Nothing可以理解为任何类型的子类型。
    val x :List[Int] = Nil
    val x :List[String] = Nil

Unit
------------------------------------
    java中方法没有返回值的使用void类型。
    scala中的unit相当于java的void.
    Unit只有一个值,()
    val x:Unit = ();



文件与正则
--------------
    //读取文件
    val it = scala.io.Source.fromFile("d:/java/1.txt").getLines()
    for(x <- it){
        println(x)
    }

    //二进制读取
    val f:java.io.File = new File("d:\java\1.txt")
    val fis = new FileInputStream(f)
    val baos = new ByteArrayOutputStream()
    val buf = new Array[Byte](f.length().toInt)
    fis.read(buf)
    fis.close()
    println(new String(buf))

    //?????缓冲流读取?????

进程控制
--------------
    import sys.process._
    //!返回的命令对执行结果,0或其他值。
    val x:Int = ("dir d:/" !)

    //!!返回字符串,x是执行的结果字符串
    val x = ("dir d:/" !!)


特质
--------------
    class RichInt extends OrderedProxy..

    1.自身类型
        限制自己可供哪些类使用。
        /**
          * Created by Administrator on 2018/2/9.
          */
        class Vip extends VipRoom{
            override def tea(): Unit = {

            }
        }

        //错误，不符合特质自身类型
        class Customer extends VipRoom{
            override def tea(): Unit = {

            }
        }

        //vip房间
        trait VipRoom {
            //只能Vip能实现该特质。
            this:Vip=>
            def tea()
        }

操作符
---------------
    1.中置操作符
        放在两个操作数的中间。
        调用的对象的方法有一个参数。
        可以使用中置操作符
        1 to 10
        1.to(10)

        class Dog = {
            def compare(d:Dog) = -1
        }

        val d1 = new Dog()
        val d2 = new Dog()
        d1.compare(d2)
        d1 compare d2

    2.一元操作符
        //前置操作符
        +        //+号
        -        //-号
        !        //boolean取反
        ~        //按位取反
        
        //将前置操作符转换成方法
        0.unary_~
        0.unary_+
        0.unary_-
        ttue.unary_!

        //赋值操作符
        var a = 0 
        a +=
        a -=
        a *=
        a /=
        var x = 0
        x -= 1
        x *= 1
        x /= 1
        x %= 1


    3.结合性
        :结尾的都是右操作符。
        val a = Array(1,2,3)

        //4,1,2,3
        a.+:(4)            //方法调用
        4 +: a            //右操作符

        val a = Array(1,2,3)
        val b = Array(4,5,6)
        a ++: b            //1,2,3,4,5,6

        1 :: 2 :: 3 :: Nil            //1,2,3
        Nil.::(3).::(2).::(1)        //1,2,3

update和apply
-------------------
    val m = mutable.HashMap[String,Int]("tom1"->100 , "tom2"->80)
    //apply
    m("tom1")
    m.apply("tom1")

    //更新
    m("tom2") = 300
    m

    //定义分数类和*方法
    class Fraction(var top:Int,var bot:Int) {
        def *(f:Fraction) = {
            Fraction(top * f.top , bot * f.bot)
        }

    }

    object Fraction{
        def apply(a:Int,b:Int) = new Fraction(a,b)
    }
    //apply
    val f1 = Fraction(1,2)
    val f2 = Fraction(1,3)
    //
    val f3 = f1 * f2
    val f4 = f1.*(f2)

提取器:unapply
------------------
    和apply相反，反解析对象，抽泣属性值的。
    class Fraction(var top:Int,var bot:Int) {
        def *(f:Fraction) = {
            Fraction(top * f.top , bot * f.bot)
        }

    }

    object Fraction{
        def apply(a:Int,b:Int) = new Fraction(a,b)

        def unapply(arg: Fraction): Option[(Int, Int)] = {
            if(arg.top == 0) None else Some(arg.top,arg.bot)
        }
    }

    object demo1{
        def main(args: Array[String]): Unit = {
            val f1 = Fraction(1,2)
            val f2 = Fraction(1,3)
            val f3 = f1 * f2
            //将f3的分子分母抽取出来，赋值给a1,b1
            val Fraction(a1,b1) = f3
        }
    }

_用法
-----------------
    import math._            //导包
    1 to 10 :_*                //转序列
    (1,2)._1                //元组访问
    val f = ceil _            //函数本身


高阶函数
----------------
    函数中的参数或者返回值也是函数。
    import scala.math._
    val x = 3.14
    ceil(x)                //4.0
    val f = ceil _        //
    f(x)
    
    //
    Array(1.1,2.2,3.3).map(f)

    //匿名函数
    (a:Int,b:Int)=>a + b
    val f = (a:Int,b:Int)=>a + b
    f(1,2)                            //调用函数

    //定义高阶函数
    def op(f:(Int,Int)=>Int,a:Int,b:Int) = f(a,b)
    def add(a:Int,b:Int) = a + b
    val f = add _
    op(f,1,2)
    op(add _ , 1,2)
    op(add, 1,2)
    op((a:Int,b:Int)=> a + b, 1,2)


    //1.高阶函数，返回值是函数
    def f0() = {
        def add(a:Int,b:Int) = a + b
        add _
    }
    f0()(1,2)

    //2.高阶函数，返回值是函数
    def f0() = { (a:Int,b:Int) => a + b }
    f0()(1,2)

    //3.
    def f0():(Int,Int)=>Int = { (a:Int,b:Int) => a + b }

    注意事项:
    函数声明:没有参数名称，只需要有类型即可。(Int,Int)=>Int
    匿名函数:有参数名称, (a:Int , b:Int) => a + b 
                         (a:Int , b:Int) =>{ a + b }:Int
    
    //函数示例
    val a = Array(1,2,3)            //1,2,3
    a.map((x:Int)=>x * 3)            //3,6,9
    a.map((x)=>x * 3)                //类型推断,省去了参数类型
    a.map(x=>x * 3)                    //省去了()
    a.map(_ * 3)                    //省去了()



柯里化
-----------------
    将多个参数转换成每次调用一个参数的函数，链条式调用即可。
    柯里化表示法，能够很好的利用类型推断和隐式值，调用简洁。
    
    //原函数
    add(x:Int,y:Int)= x + y

    //
    def add(x:Int)={
        def f(y:Int)=x+y
        f _
    }

    //柯里化,
    def add(x:Int)(y:Int)={
      x + y
    }
    def add(x:Int)(y:Int)(z:Int)={x + y + z}


控制抽象
------------------
//定义函数
def runInThread(block:()=>Unit) = {
new Thread(){
override def run(){
block()
}
}.start()
}

//调用函数
runInThread(()=>println("hello world"))

//使用换名调用表示法定义函数
def runInThread(block: =>Unit) = {
new Thread(){
override def run(){block}
}.start()
}

runInThread(println("hello world"))

List
----------------
    可重复。
    //不可变List
    val l = 1::2::3::Nil
    //
    l.++Array(4,5)


    //可变List
    import scala.collection.mutable.LinkedList
    val ll = LinkedList(1,2,3)
    val ll = LinkedList.apply(1,2,3)
    //赋值
    ll.elem = 0

    //错误,head不能赋值
    ll.head = 0 
    //
    ll.tail.elem = 0



Set
----------------
    不重复。
    val s = Set(1,2,3)
    s + 4
    s.head
    s.tail

    //循环
    s.foreach(println)

    val s1 = Set(1,2,3)
    val s2 = Set(2,3,4)
    
    //并集
    s1 | s2
    s1 union s2
    s1 ++ s2
    s1.++(s2)

    //交集
    s1 & s2
    s1.intersect(s2)

    //差集
    s1 &~ s2
    s1.diff(s2)
    s1 -- s2

    //函数应用给集合
    val l = List("tom","tomas" , "tomasLee")
    
    //转大写
    l.map(_.toUpperCase)
    //转大写
    for(x <- l) yield x.toUpperCase

化简和折叠
------------------
    //化简
    val l = List(1,2,3,4)

    //(1 + 2) + 3 + 4
    l.reduceLeft(_ + _) = 10
    l.reduceLeft(_ - _) = -8

    //1 - (2 - (3 - 4))
    l.reduceRight(_ - _) = -2


    //折叠(fold)
    l.foldLeft(0)(_ - _) = -10
    l./:(0)(_ - _) = -10
    l.foldLeft(10)(_ - _) = 0

    l.foldRight(0)(_ - _) = -2
    l.:(0)(_-_) = -2
    
    0 :: l
    Array(-1,0).toList ::: l

    //通过迭代器迭代集合
    val it = l.iterator
    while(it.hasNext)println(it.next)

模式匹配
-----------------
//常规用法
val x = '+'
x match {
case '+' => println("+++++++")
case '-' => println("-------")
case _ => println("~~~~~~~")
}

//守卫条件
val x = '1'
x match {
case '+' => println(" > 0 ")
case '-' => println(" < 0 ")
case _ if Character.isDigit(x)=> println("is number")
case _ => println("other")
}

//跟随变量
val str = "123"
str.length() match {
case 10 => println(" long string ")
case 2 => println(" short string ")
case len => println("normal string , str's length is " + len)
}

//常量控制
import  java.awt.Color._
val c = "bluegreen"
val bluegreen = "bluegreen"
c match{
  //case RED => println("red color!!") 
  //识别成常量,否则就是变量对待
  case `bluegreen` => println("red BLUEGREEN!!") 
}

//类型判断
val x:Any = "hello"
x match{
  case a:Int => println("整数")
  case b:String => println("字符")
  case c => println("其他")
}

//匹配数组,列表,元组
val arr = Array(2,"3")
arr match{
  case Array(0) => println(1)
  case Array(x,y) => println("2" + x + "," + y)
  case Array(0,_*) => println(3)
  case _ => println(4)
}

val l = 0 :: 1 ::2 :: Nil
l match{
  //0
  case 0::Nil => println(1)
  //2元素
  case x::y::Nil => println(2)
  //以0开头
  case 0::tail => println(3)
  case _ => println(4)
}

//元组
val t:Tuple2[Any,Any] = ("1","2")
t match{
  case (1,_) => println(1)
  case (y,2) => println(2)
  case _ => println(3)
}

//提取器(unapply)
val t = ("001","tomas")
val (id,name) = t

val (a,b) = BigInt(5) /% 2

系统属性
------------
//自动转换properties集合成scala的map
import scala.collection.JavaConversions._
val prop = System.getProperties
for((k,v) <- prop){
    println(k + "-->" + v)
}

样例类
--------------
    优化之后的类，方便用于模式匹配。
    内置实现hashcode，toString，serializable接口，可比较接口。
    apply()/unapply()

    abstract class Amount
    case class Dollar(v:Double) extends Amount
    case class Currency(v:Double, unit:String) extends Amount
    case object Nothing00 extends Amount

    var a: Amount= Dollar(100)
    a = Currency(100,"人民币")
    a = Nothing00
    a match{
        case Dollar(v) => println("美元 : " + v)
        case Currency(u,v) => println("货币 : " + u + " , " + v)
        case Nothing00 => println("nonnn")
    }

密封类
---------------
    sealed修饰的类，密封的所有子类必须和自己位于同一个源文件中。
    能够在一个文件中找到所有的子类。

    sealed abstract class Amount
    case class Dollar(v:Double) extends Amount
    case class Currency(v:Double, unit:String) extends Amount
    case object Nothing00 extends Amount

Option
---------------
    可空。
    sealed abstract class Option
    //有值
    case class Some[+A](x: A) extends Option
    //等价于null
    case object None extends Option[Nothing]

    //使用Option定义函数返回值，有效规避null判断问题，
    //使用None样例对象为特定空值。
    def getScore(name:String):Option[Double] = {
        if(name.equals("tom")){
            None
        }else{
            Some(100)
        }
    }

    val s = getScore("tom")
    if(s.isEmpty){
        println("没有此用户")
    }
    else{
        println("分数 ： " + s.get)
    }

偏函数
-----------------
    包含在{}内的一组case语句。
    对模式匹配中的匹配条件进行重用。
    本质上就是模式匹配，能够进行重用。
    val f:PartialFunction[Char,Int]= {case '+' => 1 ; case '-' => -1 ; case _ => 0}
    //调用偏函数
    println(f('0'))
    //判断是否定义了特定字符的处理方式。
    f.isDefinedAt('+')

类型参数
------------------
    //类泛型
    class Pair[T,S](val one:T,val two:S)

    val o1 = new Pair(100,"tom")
    //right
    val o2 = new Pair[Int,String](100,"tom")
    
    //wrong
    val o2 = new Pair[String,String](100,"tom")
    
    //方法泛型
    def middle[T](arr:Array[T]) = arr(arr.length / 2)
    middle(Array(1,2,3))

    //泛型边界,T必须是Comparable子类或实现类。
    // <: 上限
    class Pair[T <: Comparable[T]]{
        def smaller(a:T , b:T) = {
            if(a.compareTo(b) < 0) a else b
        }
    }

    val o = new Pair[java.lang.Integer]()
    println(o.smaller(1,2))

    // >: 下限 ,不好使！！
    class Pair[T](val first:T , val second:T){
        def replaceFirst[R >: T](a:R) = new Pair[R](a,second)
    }

    class Dog
    class Jing8(name:String) extends Dog
    class VipJing8(val name:String,val age:Int) extends Jing8(name)

    val j1 = new Jing8("j1")
    val j2 = new Jing8("j2")
    val j3 = new VipJing8("j3",12)

    val p1 = new Pair[Jing8](j1,j2)
    val d1 = new Dog()
    val p2 = p1.replaceFirst(j3)
    println(p2.first)
    println(p2.second)

    // <% : 视图界定,能够隐式转换成需要的类型。
    class Pair[T <% Comparable[T]]{
        def smaller(a:T , b:T) = {
            if(a.compareTo(b) < 0) a else b
        }
    }

    val o = new Pair[Int]()
    println(o.smaller(1,2))

    //型变
    1.协变
        class Pair[+T]
        
        class Person
        class Student extends Person
        Pair[Student]是Pair[Person]的子类型

    2.逆变
        class Pair[-T]

        class Person
        class Student extends Person

        Pair[Student]是Pair[Person]的父类型


隐式转换
----------------
    1.隐式转换函数
        使用implicit修饰的带有单个参数的函数。
        val f1 = Fraction(1,2)
        //隐式转换函数
        implicit def fff(n:Int) = Fraction(n,1)
        val f2 = f1 * 3
        println(f2.top)

        //java转换包
        import scala.collection.JavaConversions._

    2.隐式参数
        //
        case class Decorator(val left:String , val right:String)
        //隐式参数
        def quote(what:String)(implicit dec:Decorator) = dec.left + what + dec.right
        //隐式值
        implicit val d = Decorator("{{{", "}}}")
        //
        println(quote("hello"))

scala实现单词统计
-----------------
    //加载文件
    val it = Source.fromFile("d:/1.txt").getLines()
    var list:List[String] = Nil

    for(line <- it){
        list = line :: list
    }
    //统计单词个数,压扁
    val list2 = list.flatMap(_.split(" "))
    val list3 = list2.groupBy((s:String)=>s)

    //def f1(a:Tuple2[String,List[String]]) = (a._1 , a._2.length)
    val list4 = list3.map((a:Tuple2[String,List[String]])=>(a._1,a._2.length))
    println()


    //排序，分组，转换list，
    val it = Source.fromFile("d:/1.txt")
    val doc = it.getLines().mkString(" ")
    val list = doc.split(" ").toList

    val list2 = list.groupBy((s:String)=>s).map((t:Tuple2[String,List[String]])=>(t._1,t._2.length))


    val list3 = list2.toList
    val list4 = list3.sortBy((t:Tuple2[String,Int]) => -t._2)

    println(doc)