Scala-02

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

    object            //静态成员
    class            //class
    trait            //接口
    def xxx(a:Int):Unit{}
    val                //常量
    var                //变量

    map(""->"",v->k)//

    (1,2,3,4,65)    //tuple,<= 22

    while(){
    }

    for(x <- 1 to 10 if xxxx) yield

    x = 100 ;
    Unit            //()
    val a:Unit = ();//defer推段。
    函数的递归调用。

scalac xxx.scala
scala xxx.scala            //

new Array(100)            //100个元素
Array(100)                //1个元素，值是100，apply();

"hello"(1)                //charAt "hello".apply(1);

object                    //
companions object        //和类同名,必须定义在一个scala文件中。
package object            //package.class,

class Person(.....){
    def this(...){
        this();
    }
}

扩展
----------------
    class Dog extends Animal{
        //重写,覆盖
        //overload
        override def run()={...}
    }

类型检查和转换
---------------
    $scala>class Animal{}
    $scala>class Dog extends Animal{}
    $scala>val d = new Dog();
    $scala>d.isInstanceOf[Animal]            //true,===> instanceOf
    $scala>val a = d.asInstanceOf[Animal]    //强转,===> (Animal)d

    //得带对象的类
    $scala>d.getClass                        //d.getClass();
    $scala>d.getClass == classOf[Dog]        //精确匹配

    $scala>class Animal(val name:String){}
    $scala>class Dog(name:String,val age:Int) extends Animal(name){}

    //抽象类
    $scala>abstract class Animal(val name:String){
        //抽象字段，没有初始化。
        val id:Int  ;
        //抽象方法，没有方法体，不需要抽象关键字修饰。
        def run() ;
    }

scala类型树
------------------
    Null        //
    Nothing        //

    Any
     |
    /|\
     |------------AnyVal <|------Int|Boolean|...|Unit
     |------------AnyRef <|------class ...

文件
----------------
    import scala.io.Source ;
    /**
      * Created by Administrator on 2017/4/18.
      */
    object FileDemo {
        def main(args: Array[String]): Unit = {
            val s = Source.fromFile("d:/hello.txt") ;
            val lines = s.getLines();
            for(line <- lines){
                println(line)
            }
        }
    }
    
    //
    scala.io.Source.fromFile(...).mkString()

    //通过正则
     val str = Source.fromFile("d:/hello.txt").mkString
            val it = str.split("\\s+")
            for(i <- it){
                println(i)
            }
        

正则表达式
------------------
    <a href="xxkdkdkdkdkd">

trait
-----------------
    如果只有一个trait使用extends进行扩展，如果多个，使用with对剩余的trait进行扩展。
    trait logger1{
        def log1() = println("hello log1");
    }

    trait logger2{
        def log2() = println("hello log2");
    }
    
    class Dog extends logger1 with logger2{
        
    }

    //trait之间也存在扩展。
    trait logger1{
        def log1() = println("hello log1");
    }
    trait logger2 {
    }
    trait logger3 extends logger2 with logger1{
    }

    //with trait是需要对每个trait都是用with
    class xxx extends A with T1 with T2 with ...{
        ...
    }

    //自身类型
    trait logger{
        this:Dog =>
        def run() = println("run....")
    }

    trait Dog {
        
    }

    trait Jing8 extends Dog with logger{
        
    }

    class Cat extends logger{
        
    }

操作符
-------------------
    //中置操作符
    scala> 1 + 2            //
    scala> 1.+(2)            //

    //单元操作符
    scala> 1 toString        //+: -:取反 !:boolean取反 ~:按位取反

    //赋值操作符
    $scala>+= / -= *= / /=

    //:表示右结合,只有:结尾的操作符是右结合,优先级从右侧开始
    scala>val l = Nil        //构造空集合.
    scala>1::2::Nil            //1::(2::Nil)
    scala>Nil.::(2)

apply()/update()
------------------
    Array(100)            //Array.apply(100);
    Array(100) = 200    //Array.update(200)

unapply(),是apply的逆向过程
------------------
    //定义类
    class Fraction(val n:Int,val d:Int){
    }

    object Fraction{
        //通过
        def apply(n : Int,d:Int)= new Fraction(n,d) 
        //逆向过程
        def unapply(f:Fraction) = Some(f.n,f.d)
    }

    scala>val f = Fraction(1,2)            //apply(...)
    scala>val Fraction(a,b) = f            //unapply(...)

高阶函数
---------------------
    scala>def add(a,b) = a + b

    scala>val f = add _                    //将函数赋值给一个变量,函数类型变量。

    scala>def multi(n:Int) = n * 2
    scala>def f = multi _                //_ 表示取出函数本省
    scala>Array(1,2,3,4).map(f)
    
    //匿名函数
    scala>(n:Double)=>3 * n                //
    scala>val f = (n:Double)=>3 * n
    scala>Array(1,2,3,4).map((x) => x * 3);
    scala>Array(1,2,3,4).map{(x) => x * 3};

    //遍历数组时，输出元素值，每个元素平方返回。
    

    f1:add
    f2:sub
    
    //
    call(a:Int,b:Int,f1..,f2..){
        if(a > 0) ===> add
        if(a <= 0) 

        return f1 / f2 ;
    }
    
    //
    call(1,2,fadd,sub) = 3
    call(-1,2,fadd,sub) = -3

    //高阶函数
    def call(a:Int,b:Int,f1:(Int,Int)=>Int,f2:(Int,Int)=>Int)={
        if(a > 0){
            f1(a,b) ;
        }
        else{
            f2(a,b) ;
        }
    }
    def add(a:Int,b:Int) = a + b
    def sub(a:Int,b:Int) = a- b

    val f1 = add _

    val f2 = sub _

    call(1,2,f1,f2)            //3
    call(1,2,add _ ,sub _)    //
    call(1,2,add,sub)    //

    //call函数提升
    call():{
        if(a > 0){
            f1(a,b) ;
        }
        else{
            f2(a,b) ;
        }

        //y = []x
    
    }

    系数 : y = 2x

    val f = call(1,2,f1,f2)
    f(100) = 300 ;

    call(1,2,add _,sub _)(100) = 300

    def call(a:Int,b:Int,f1:(Int,Int)=>Int,f2:(Int,Int)=>Int)= {
        var n = 0 ;
        if(a > 0){
            n = f1(a,b) ;
        }
        else{
            n = f2(a,b) ;
        }

        //
        def multi(x:Int) = x * n ;
        multi _
    }
    
    //
    call(1,2,(a:Int,b:Int)=>a + b , (a:Int,b:Int)=> a- b)(100)
    call(1,2,a,b=>a + b , (a,b)=> a- b)(100)                    //wrong

    //定义高阶函数
    def valueAt(f:(Double)=>Double) = f(0.25)

    //
    valueAt(cail _)

    //              参数       = 函数体(函数)
    def mulby(factor : Double) = (x:Double) => x * factor
    mulby(2)
    

    //函数推断
    def valueAt(f:(Double)=>Double) = f(0.25)
    valueAt((x:Double)=>x * 3)                //定义类型
    valueAt((x)=>x * 3)                        //推断类型
    valueAt(x=>x * 3)                        //省略()
    valueAt(x=>x * 3)                        //省略()
    valueAt(3 * _)                            //参数在右侧出现1次，就可以使用_代替。

    //高级函数
    scala>val arr = Array(1,2,3,4)
    scala>arr.map(2 * _);                    //每个元素x2
    scala>arr.map((e:Int)=> e * 2);            //每个元素x2
    scala>arr.map(_ * 2);                    //每个元素x2

    //输出三角形
    scala>(1 to 20).map("*" * _).foreach(println)

    //hdfs，分布式存储

    //reduceLeft,有左至右
    //1,2,3 ==> (1 - 2) -3)    = -4

    MR:MapTask + reduceTask,映射化简.

    //reduceRight,由右至左
    //1,2,3 ==>1 - (2 - 3)= 2
    //1,2,3,4 ==> 1 - (2 - (3 - 4)) = -2
    //1,2,3,4 ==> 1 - (2 - (3 - 4)) = -2

柯里化
------------------
    scala>def mul(a:Int,b:Int) = a  * b;
    scala>mul(1,2)

    scala>def mulone(a:Int) = {(x:Int) => a * x ;}
    scala>mulone(1)(2)

//控制抽象
-----------------
    //定义过程，启动分线程执行block代码.
    def newThread(block :()=>Unit){
        new Thread(){
            override def run(){
                block() ;
            }
        }.start();
    }

    newThread(=>{
                    (1 to 10).foreach(e => {
                                                val tname = Thread.currentThread.getName();
                                                println(tname + " : " + e) ;
                                            })
                  }
    ) ;

    //省略()
    def newThread(block: =>Unit){
        new Thread(){
            override def run(){
                block ;
            }
        }.start();
    }
    //
    newThread{
                    (1 to 10).foreach(e => {
                                                val tname = Thread.currentThread.getName();
                                                println(tname + " : " + e) ;
                                            })
                  };

    //

集合
-------------
    //Nil
    scala>1::2::Nil                //Nil空集合
    scala>var list = List(2,4)
    scala>9::list

    scala>def sum(list:List[Int]):Int = {
                if (list == Nil) 0 else list.head + sum(list.tail)
            }

    //通过模式匹配实现sum求和。
    def sum(list:List[Int]):Int= list match{
        case Nil => 0
        case a::b=> a + sum(b) 
    }

    //添加删除元素操作符

    scala>val set = Set(1,2,3)
    scala>set + (1,2,3,5)
    scala>set - (1,2,3,5)
    
    scala>val l1 = List(1,2)
    scala>val l2 = List(3,4)
    scala>l1 ++ l2                //1234 ::
    scala>l1 ++: l2                //1234 === :::

    scala>val s1 = Set(1,2,3)
    scala>val s2 = Set(2,3,4)
    scala>s1 | s2                //并集
    scala>s1 & s2                //交集
    scala>s1 &~ s2                //差集(1,2,3) - (2,3,4) = (1)

    // += 操纵的是可变集合,操纵一个元素
    // ++= 操纵的是可变集合,操纵集合
    // +: 操纵的是不可变集合，产生新集合
    scala>import scala.collection.mutable.{Set => SSet}

    scala>buf.take(2)            //提取前2个元素
    scala>buf.drop(2)            //删除前2个元素
    scala>buf.splitAt(2)        //在指定位置进行切割，形成两个集合。
    scala>val b1 = ArrayBuffer(1,2,3)
    scala>val b2 = ArrayBuffer(3,4,5,6,)
    scala>b1.zip(b2)            //(1,3)(2,4)(3,5)
    scala>b1.zipAll(b2,-1,-2)    //(1,3)(2,4)(3,5)(-1,-2)
    scala>b1.zipWithIndex()        //(,0)(,1)(,2)(,3)        //元素和自己的索引形成tuple.

    (0 - 1) - 7 - 2 - 9            //-19
    1  - (7 - (2 - (9 - 0))_    //-13
    ..