大数据之scala（二） --- 映射，元组，简单类，内部类，对象Object，Idea中安装scala插件，trait特质[接口]，包和包的导入

一、映射<Map>
-----------------------------------------------------
    1.创建一个不可变的映射Map<k,v>  ==>  Map(k -> v)
        scala> val map = Map("tom" -> 1 , "tomasLee" -> 2 , "join" -> 3)
        map: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, tomasLee -> 2, join -> 3)
        注意，这种方式创建的映射的元素是不可以改变的

    2.访问Map
        scala> map("tom")

    3.创建可变的映射
        scala> val map = scala.collection.mutable.Map(100 -> "tom",200->"tomsLee",300 -> "join")
        map: scala.collection.mutable.Map[Int,String] = Map(200 -> tomsLee, 100 -> tom, 300 -> join)

        scala> map(100) = "222"
        scala> map
        res1: scala.collection.mutable.Map[Int,String] = Map(200 -> tomsLee, 100 -> 222, 300 -> join)

    4.创建空的可变映射：如果想从一个空映射开始，你需要选择一个映射实现hashmap和map的参数[Int,String]
        scala> val map = new scala.collection.mutable.HashMap[Int,String]
        map: scala.collection.mutable.HashMap[Int,String] = Map()

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

        scala> map(100)="111"

        scala> map
        res4: scala.collection.mutable.HashMap[Int,String] = Map(100 -> 111)

    5.追加和移除元素
        a.对于可变映射
            scala> val map = scala.collection.mutable.HashMap[Int,String]()
            map: scala.collection.mutable.HashMap[Int,String] = Map()

            //添加元素
            scala> map += (1->"100",2->"200")
            res5: map.type = Map(2 -> 200, 1 -> 100)

            //移除元素
            scala> map -= 2
            res9: map.type = Map(1 -> 100)

        b.对于不可变映射
            不可变映射是不能添加和移除元素的，但是可以变成另外一个映射
            scala> val map = Map("tom" -> 1 , "tomasLee" -> 2 , "join" -> 3)
            map: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, tomasLee -> 2, join -> 3)

            //immutable不可变集合添加元素是错误的
            scala> map +=("xiao" -> 4)
            <console>:12: error: value += is not a member of scala.collection.immutable.Map[String,Int]
                   map +=("xiao" -> 4)

            //但是可以将map元素添加或者移除一个元素，之后重新赋值给一个新的不可变映射
            scala> val map1 = map + ("xiao" -> 4)
            map1: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, tomasLee -> 2, join -> 3, xiao -> 4)

            scala> map - "tom"
            res15: scala.collection.immutable.Map[String,Int] = Map(tomasLee -> 2, join -> 3)

            scala> map
            res17: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, tomasLee -> 2, join -> 3)

    6.迭代
        scala> for((k,v) <- map) println(k + ":" + v)
        tom:1
        tomasLee:2
        join:3

        //得到一个类似Set("tom", "tomasLee", "join")
        scala> map.keys
        res19: Iterable[String] = Set(tom, tomasLee, join)

        scala> map.keySet
        res20: scala.collection.immutable.Set[String] = Set(tom, tomasLee, join)

        //遍历values
        scala> for(v <- map.values) println(v)
        1
        2
        3

        //遍历keys
        scala> for(v <- map.keys) println(v)
        tom
        tomasLee
        join

        //遍历keySet
        scala> for(v <- map.keySet) println(v)
        tom
        tomasLee
        join

        //遍历values
        scala> for(v <- map.keySet) println(map(v))
        1
        2
        3

    7.yield 迭代产生新的映射，比如kv调换
        scala> map
        res12: scala.collection.mutable.HashMap[Int,String] = Map(1 -> 100)

        scala> for((k,v)<- map ) yield(v,k)
        res11: scala.collection.mutable.HashMap[String,Int] = Map(100 -> 1)


二、元组tuple
-------------------------------------------------------------------
    1.元组是不同类型的值的聚集 -- 映射是键值对的集合，键值对是元组的最简单的形式

    2.元组的值是通过将单个的值包含在圆括号中构成的
        (1,3.14,"Fred")

    3.定义一个元组Tuple,最多22个元素
        scala> val t = (1,3.14,"Fred")
        t: (Int, Double, String) = (1,3.14,Fred)

    4.访问元组中的元素
        scala> t._1
        res27: Int = 1

        scala> t _2
        res28: Double = 3.14

        scala> t._3
        res29: String = Fred

    5.直接取出元组中的所有元素
        scala> val(a,b,c) = t
        a: Int = 1
        b: Double = 3.14
        c: String = Fred

    6.数组的zip(咬合/拉链)
        scala> val h = Array(1,2,3)
        h: Array[Int] = Array(1, 2, 3)

        scala> val w = Array(4,5,6)
        w: Array[Int] = Array(4, 5, 6)

        scala> h.zip(w)
        res31: Array[(Int, Int)] = Array((1,4), (2,5), (3,6))


三、简单类
-----------------------------------------------------
    1.定义类
        class Person{

            //定义变量,私有类型,必须初始化
            //set/get也私有
            private var id = 0 ;

            //不声明就是public，public的常量自带get,没有set
            val age = 100 ;

            //不声明就是public，public的变量自带get，set
            var name = "tom" ;

            //默认public
            def incre(a:Int) = {id += a ;}

            //如果定义函数时，没有加(),调用就不能加()
            def current() = id

        }

    2.使用类
        scala> var p = new Person()
        p: Person = Person@55dfebeb

        //声明方法的时候带(),调用方法的时候可以带也可以不带
        scala> p.current
        res0: Int = 0

        scala> p.incre(2)

        scala> p.current()
        res2: Int = 2

        //调用get方法。注意p.name(),说错误的，不能加括号，因为定义的时候没有括号
        scala> p.name
        res5: String = tom

        //调用set方法赋值，要加括号
        scala> p.name_=("jarry")

        scala> p.name
        res9: String = jarry

        //直接给公有的变量赋值
        scala> p.name = "kkk"
        p.name: String = kkk

    3.private[this] 私有修饰 -- 对象私有化
        private var value = 0;                      //其他对象可以通过一些手段访问
        private[this] var value = 0;                //只能在自己对象中访问

    4.@BeanProperty 注解
        当你将scala字段添加注解@BeanProperty的时候，自动生成javabean对应的setName() 和 getName()方法
        class Person{

            // _ 表示默认值[Unit]
            @scala.reflect.BeanProperty var name:String = _

        }

    5.构造函数
        a.scala构造函数分为主构造器和辅助构造器

        b.辅助构造器
            辅助构造器的名称都叫this
            每一个辅助构造器都必须先调用，先前已经定义的其他辅助构造器或者主构造器
            class Person{

                var name = "";
                var age = 0;

                def this(name:String) {
                    this();           //调用主构造器this()
                    this.name = name;
                }

                def this(name:String , age:Int) {
                    this(name);         //调用辅助构造器this(name)
                    this.age = age;
                }

            }

            scala> var p = new Person("tom", 12);
            p: Person = Person@2eb0cefe

            scala> p.name
            res13: String = tom

            scala> p.age
            res14: Int = 12

        c.主构造器 : 直接放置在类名之后
            class Person(var name:String, var age:Int){
                //因为主构造器的参数会被编译成字段，所以下面代码可省略
                //var name = "";
                //var age = 0;

                //def this(name:String , age:Int) {
                //    this(name);         //调用辅助构造器this(name)
                //    this.age = age;
                //}

                //下面这些语句是在构造函数中，也就是说，每次创建对象都会调用一次
                println("xxxxxx");
                println("xxxxxx");
                println("xxxxxx");

                age += 100;

                def hello() = {println("hello" + age);}

            }


四、嵌套类 -- 内部类
-------------------------------------------------------------
    1.对于scala，你可以在类中定义类，可以在方法中定义方法
        class Person{
            class Heart(val count : Int){
                println("*****")
            }

            var name = "tom";
            def fun(arg : String) = {
                def fun1()
                {

                }
                def fun2()
                {

                }
            }
        }

    2.new Person().new Heart(80);


五、对象Object
------------------------------------------------------------
    1.单例对象
        a.scala中没有静态方法和静态字段，靠单例对象来实现
            object Util{
                var name = "tom";
                def hello() = {println("hello")};
            }

        b.scala> Util.name
          res3: String = tom

          scala> Util.hello
          hello

          scala> Util.name = "ccc"
          Util.name: String = ccc

    2.类和类的伴生对象（类中的某个成员是静态的）
        a.类和它的伴生对象可以互相访问私有成员 -- 但是，class和object必须在同一个文件中
        class Account{
            var id = Account.uniqueNumber();
            ...
        }

        object Account{
            private def uniqueNumber() = { return 0 };
        }

    3.扩展[继承]类和特质[接口]的对象
        a.scala中的抽象类
            abstract class UndoAction (val description : String ){
                def undo():Unit
                def redo():Unit
            }

        b.scala中的继承
            //类的继承
            class DoNothingAction extends UndoAction ("Do nothing"){
               override def undo(){}
               override def redo(){}
            }

            //DoNothingAction这个对象（静态对象）可以被所有需要缺省行为对象的地方共有（需要do nothing就调用）
            object DoNothingAction extends UndoAction ("Do nothing"){
                override def undo(){}
                override def redo(){}
            }

    4.apply方法
        a.Object(参数1,....,参数N)
            这样一个apply方法，返回的是伴生类的对象，比如Array("aaa","bbb","ccc")返回的是一个String的数组;

        b.Array(100) 和 new Array(100)的 区别
            Array(100)，返回的是一个只包含一个元素100的数组。100表示元素
            new Array(100),返回的是一个有100个元素，每个元素都为空的数组。100表示数组中元素的个数

            scala> Array(100)
            res1: Array[Int] = Array(100)

            scala> new Array(100)
            res2: Array[Nothing] = Array(null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null)

        c.自定义Apply方法--示例
            object Hello
            {
                  def apply(s:String) = {println(s)};
            }

            scala> Hello("hello")
            hello

            scala> Hello("hai")
            hai

            scala> Hello.apply("hai")
            hai

        d.应用程序对象 -- 带main函数的object[因为main函数是静态的，所以只能在对象中]
            object Hello
            {
                def main(args : Array[String]) = {
                    println("xxx");
                }
            }

            scala> Hello.main(Array())
            xxx


六、Idea中安装scala插件
-------------------------------------------------------------
    1.打开idea --> File --> settings --> plugins --> install xxx -->
     --> 找到scala-intellij-bin for xxx.zip 或者使用网上下载安装方式进行安装

    2验证安装是否成功
        a.创建scala模块，选择sdk,添加maven支持

        b.编写object
            object Hello {
              def main(args: Array[String]): Unit = {
                println("Hello world");
              }
            }

        c.运行object


七、trait特质[接口]
-----------------------------------------------------------
    1.创建trait
        trait Hello{

        }

    2.编译scalac
        cmd:D:\share\scala\workspace> scalac trait-1.scala

    3.反编译
        cmd> javap Hello.class

        public interface Hello {
        }


八、包和包的导入
-----------------------------------------------------------
    1.包对象
        //编译包对象，编译完之后生成以xxx为package，下面含有类package.class + package.class
        // .../a/aa/aaa/people/package.class
        // .../a/aa/aaa/people/package$.class
        package a.aa.aaa;

        package object people
        {
            var name = "hello";
        }

    2.包的可见性约束
        package a.aa.aaa;

        class Person{
            //在package包及其子包中可见
            private[people] def func() = { println("xxx")}
            //在aaa包及子包中可见
            private[aaa] def func1() = {println("---")}
        }

    3.包的导入
        a._表示通配
            import java.awt.Color._

        b.选取器selector
            //只引入包中的几个成员类
            import java.awt.{Color,Font}

        c.选取器重命名，别名
            比如 HashMap 在 java.util 和 scala.collection中都有。如果想同时导入两者，那么就必须将其中一个HashMap指定别名
            否则就不知道hashMap指向的是哪个包了

            import java.util.{HashMap => JavaHashMap}
            import scala.collection.mutable.HashMap

        d.隐藏导入成员
            //将java包中的HashMap隐藏掉，不使用
            import java.util.{HashMap => _}
            import scala.collection.mutable.HashMap