Scala学习-常用集合/模式匹配和样例类/泛型/隐式转换（thirty-seven day）

Scala学习继续篇

常用集合
--------------
    1.list
        val list = List(1,2,3,4)
        list.head                //1
        list.tail                //List(2,3,4)
        list.tail.tail.tail.tail//Nil

        def sum(list:List[Int]):Int = if (list == Nil) 0 else list.head + sum(list.tail)
        sum(1::2::3::4::Nil)    //10

        Array(1,2,3).toList ::: list        //
        list.slice(1,3)                        //[1,3)
        list.reverse()                        //倒序

    
    2.Set
        不重复，默认使用hash
        val s1 = Set(1,2,3)
        val s2 = Set(2,3,4)
        s1.intersect(s2)        //交集, s1 & s2 (2,3)
        s1.union(s2)            //并集 ,s1 + s2
        s1.diff(s2)                //差集 , s1 -s2

        s1 | s2                    //并集
        s1 & s2                    //交集
        s1 &~ s2                //差集

        s1 ++ s2                //并集
        s1 -- s2                //差集

    
    3.集合的化简与折叠
    
        3.1)reduceLeft
            val list = List(1,2,3,4)
            list.reduceLeft(_+_)
        
        3.2)foldLeft(init)(op)
            /:
            和reduceLeft相似，但是带有一个初始值。
            list.foldLeft(10)(_-_)

            (10 - 1) - 2 ) - 3 4 = 0

        3.3)foldRight
            :\
            foldRight(10)(_-_)
            1 2 3 4 10                //8
            1 2 3 10 4                //-4
        
        3.4)zipWithIndex
            list.map(_ * 100).zipWithIndex

        
    4.并行集合
        val list = (1 to 10).toList
        list.map(e=>{
            val tname = Thread.currentThread().getName()
            println(tname + " : " + e)
            e * 2
        })

        list.par.map(e=>{
            val tname = Thread.currentThread().getName()
            println(tname + " : " + e)
            e * 2
        })
    

模式匹配和样例类
-----------------
    1.模式匹配
        等价于java的switch case
        val c = '+'
        c match{
            case '+' => println(111)
            case '-' => println(222)
            case _ => println(0)
        }

        //匹配常量
        val color = Color.RED
        val x = color match{
            case Color.RED => 1
            case Color.GREEN=> 2
            case _ => 0
        }
        println(x)

        //守卫条件
        val x = c match{
          case '+' => 1
          case '-' => -1
          case _ if Character.isDigit(c) => 'N'
          case _ => 'X'
        }

        //使用变量
        val str = "hello"
        str(0) match{
          case '+' => println(1)
          case '-' => println(2)
          case ch => println(ch)
        }

        //常量问题,大写会识别成常量，
        //小写是变量，如果让小写也是常量，使用``标出
        val str = "hello"
        val ch = 'h'
        str(0) match{
          case '+' => println(1)
          case '-' => println(2)
          case `ch` => println(`ch`)
        }

        //类型匹配
        val x:Any = "abc"
        x match{
          case a:Int => println(1)
          case a:String => println(2)
          case a:Float => println(3)
          case _ => println(0)
        }

        //匹配数组
        val arr = Array[Int](1,2,3)
        arr match{
          //case Array(0) => println(1)            //精确匹配(0)
          case Array(x,y) => println(2)            //匹配2个元素
          case Array(0,_*) => println(3)        //匹配0开始
          case _ => println(4)                    //
        }

        //匹配集合
        val list = 0::1::2::Nil
        list match{
          case 0::Nil => println(1)                //0
          case x::y::Nil => println(2)            //x,y
          case 0::tail => println(3)            //0,...
          case _ => println(4)
        }

        //匹配元组
        val t = (1,2)
        t match{
          case (0,_) => println(1)
          case (y,0) => println(2)
          case _ => println(3)
        }

        //提取器unapply / unapplySeq
        val arr = Array(1,2,3)
        arr match{
          case Array(x,y,z)=> printf("x=%d,y=%d,z=%d" , x , y  ,z)
          case _ => println("0")
        }

        //多个变量声明模式
        val (x,y,z) = (1,2,3)
        x = 1
        y = 2
        z = 3

        //抽取前两个元素依次赋值
        val Array(x,y,_*) = Array(1,2,3,4,5)

        val map = Map(1->"tom1" , 2->"tom2",3->"tom3")
        for((k,_) <- map) println(k)
        for(t <- map) println(t._1)

样例类
------------------
    特殊类，经过了优化处理，经常用于模式匹配。
    好处是内置实现了众多scala常用的功能，比如serializable、
    compare、apply、unapply
    abstract class Dog
    case class Jing8(var name:String) extends Dog
    case class Shapi(var name:String) extends Dog

    $scala>:javap -p Dog
    $scala>:javap -p Jing8
    $scala>:javap -p Jing8$
    $scala>:javap -p Shapi
    $scala>:javap -p Shapi$

    val jing8 = Jing8("ttt")
    val Jing8(y) = jing8

    val d:Dog = Jing8("tom")
    d match{
      case Jing8(n) => println("jing8: " + n)
      case Shapi(n) => println("Shapi : " + n)
      case _ => println("nothing")
    }

密封样例类
-------------------
    必须将样例子类和父类定义在一个scala文件中。
    sealed abstract class Dog
    case class Jing8(var name:String) extends Dog
    case class Shapi(var name:String) extends Dog

偏函数
-------------------
    包含在{}内的一组case语句是偏函数(PartialFunction[A,B])。
    该函数有两个方法，apply()对匹配到的模式进行计算，isDefinedAt()
    判断定义了指定的情况。
    让模式匹配语句重用成为可能。
    val f :PartialFunction[Char , Int] = {
      case '+' => 1
      case '-' => -1
      case c if (Character.isDigit(c)) => 9
    } 

    f('+')            //1
    f('-')            //-1
    f('1')            //9
    f('x')            //异常
    f.isDefinedAt('x')
    f.apply('+')
    f('+')

尾递归
-------------------
    可以进行优化，将递归转换成循环实现，避免栈的溢出。
    def sum(args:Seq[Int]):BigInt = {
      if(args.isEmpty) 0 else args.head + sum(args.tail)
    }
    sum(1 to 10000)                    //溢出

    //实现了尾递归
    def sum2(x:Seq[Int] , part :BigInt):BigInt = {
      if(x.isEmpty) part else sum2( x.tail ,x.head + part)
    }
    sum2(1 to 100000 , 0)            //ok

    def out(str:String):Unit= {
      out(str)
      println(str) 
    }

泛型
-------------------
    1.类上泛型
        class Pair[T,S](var first:T , var second:S) 
        val p = new Pair[Int,String](100,"tom")
        val p = new Pair(100,"tom")

    2.方法上泛型
        def mid[T](arr:Array[T]) = arr(arr.length / 2)
        mid[Int](Array(2,3,4))
        mid(Array(2,3,4))

    3.类型上限界定
        class Pair[T <: Comparable[T]] (var a:T ,var b:T)
        val p = new Pair("100","100")
    
    4.类型下限界定
        class Pair[T >: Jing8](var a:T ,var b:T)
        ???
    
    5.视图界定
        class Pair[T <% Comparable[T]] (var a:T , var b:T)
        val p = new Pair(100,200)

    6.型变
        6.1)协变
            class Pair[+A]
            
        6.2)逆变
            class Pair[-A]
            
隐式转换
------------------
    1.隐式转换函数
        object Utils{
            implicit  def int2Fraction(n:Int) = {
                Fraction( n, 1)
            }
        }

        import Utils._
        3 * Fraction(1,2)
    
    2.隐式参数
        def dec(str:String)(implicit pre:String)

    3.隐式值
        implicit val xx:String = "<<<"
        def dec("hello")

    4.SAM
        single abstract method
        
json
------------------
    {"id":1 , "name":"tom"}
    [
        {},
        {}
    ]