Scala 学习 进击大数据Spark生态圈----个人笔记

学习Scala 进击大数据Spark生态圈
总结：

第一章：
    简单讲解了一下Scala的优劣势

第二章：
    val：常量(值)  会自动生成get方法
    var: 变量        自动生成get/set方法

    lazy属性是遇到Action操作才会执行
    优点：大数据需要提前加载的时候不会占用整个系统很多资源
    缺点：不判断程序或加载数据的对错，只有在Action运行时才发现
    IDEA开发工具的使用：
        1、windows下载maven，配置环境变量
        2、plugins 可以手动添加Scala包，也可以idea下载

第三章：
    def 函数名(可以无参数，也可以有参数): 返回类型(Unit无返回类型) {
    //函数体
    如果有返回类型，最后一行被当做是返回类型，不需要return
    }
    
    如果函数名(无参数) 调用时可以直接函数名
    默认参数：可以写一个默认参数函数名(a:Int = 3)，如果没有赋予其它参数，默认a=3
    命名参数：参数名对应好了，顺序可以错乱
    
    循环：
    1 to 10 （1,2,3,4,5,6,7,8,9,10） 1.to（10）
    1 until 10 （1,2,3,4,5,6,7,8,9） 1.until（10）
    Range(1,10) （1,2,3,4,5,6,7,8,9）
    
    for(变量 <- 要遍历的数据) 
    for(变量 <- 要遍历的数据   条件)
    x.foreach()等价于for循环
    while(循环条件)
    
    根据输入的数据不定参数进行计算
    例：
        println(num(1,2,3))
        println(num(1,2,3,4))

        def num(no:Int*) = {
          var result = 0
          for(i <- no){
            result += i
          }
          result
        }
    
第四章
    封装：属性、方法封装到类中（类是被抽象出来的）
        属性：person  
            private int id, String name, date birthday   geter/seter
        方法：eat sleep run
    继承：
        父类和子类之间的关系
            子类继承父类，并且还可以重写override
            子类继承父类，如果父类有的属性，子类可以不加var/val，父类的方法会执行
        重写：子类需要修改父类的方法、属性时需要进行重写 override xxx
        抽象类：类的一个或者多个方法、属性没有实现（只有定义）
                想要调用，必须实现所有的类、方法，否则不能被调用
        
    多态：父类的引用指向子类
        Person person = new Person()
        User user = new User()
        val p = new User()  //父类接口，子类实现功能
        
    类的定义：
        private 只在当前类中调用
        _ 占位符，使用占位符必须指定var的数据类型
        
    构造器：
        主构造器：
            跟在类名后面的属性叫主构造器 class Person（val name:String, val age:Int）
        附属构造器:
            def this(name:String, age:Int, gender:String){
                this(name,age)   //附构造器第一句话必须调用主构造器或者其它附属构造器
                this.gender=gender
            }
    伴生类、伴生对象：
        如果有一个class，还有一个和class同名的object， class是object的伴生类，object是class的伴生对象
        object类可以直接val p = Person()  
    APPLY方法：
        在object的apply方法中new class
        类名() 调用的object.apply
        对象() 调用的class.apply
    case class：通常用在模式匹配中，调用时不用new，直接调用即可
    trait：需要多个继承的时候with链接

第五章
    Array 定长数组，定义以后数组长度不能改变
    可变数组：scala.collection.mutable.ArrayBuffer   +增加数据，++需要加入Array
    不可变数组：scala.collection.immutable._
    List: Nil 是一个不可变的空集合List，是有序的可以重复的   :_* 可以将Seq转化为list
    Buffer：ListBuffer、ArrayBuffer 带Buffer都是可变的
    Set：数据是不能重复的
    Map:(key-value）键值对操作
    
第六章
    匹配模式：
        变量 match{
            case x => xxx  
            case _ => xxx   //相当于java的 default
        }
    条件模式匹配：
            变量 match{
            case x => xxx  
            case _ if(xxx) => xxx   //注意执行的先后顺序
            case _ => xxx   //相当于java的 default
        }
    数组匹配：
        def NameScore(array: Array[String]): Unit ={

            array match{
              case Array("zhangsan") => println("zhangsan")
              case Array(x,y) => println("x,y")
              case Array("zhangsan", _*) => println("Hi:zhangsan other one")   // _* 无限匹配
              case _ => println("erveryone")
            }
        }
        NameScore(Array("zhangsan"))
        NameScore(Array("zhangsan","lisi", "wangwu"))
        NameScore(Array("zhangwu"))
    List匹配
      def NameScroe(list: List[String]): Unit ={
        list match{
          case "zhangsan"::Nil => println("zhangsan")
          case x::y::Nil => println("x,y")
          case "zhangsan":: tail => println("Hi:zhangsan other one")
          case _ => println("erveryone")
        }
      }

        NameScroe(List("zhangsan","wangwu"))
        NameScroe(List("zhangsan","lisi", "wangwu"))
        NameScroe(List("zhangwu"))
    类型匹配：
      def ObjType(obj: Any){
        obj match{
          case x:Int => println("Int")
          case x:String => println("String")
          case x:Map[_,_] => x.foreach(print)
          case _ => println("other")
        }
      }

      ObjType(1)
      ObjType("1")
      ObjType(Map("key"->"value"))
    异常处理：
    try{
        //要执行的代码
    }catch{
        //可以代码执行错误后，要进行提示或其它信息写到这里
    }finally{
        //一定会执行，记得要把资源关闭
    }
    case class 对类进行模式匹配，必须要定义一个顶级的类
    Some&None  模式匹配：
      val b = Map("PK" -> 18, "zhangsan" -> 12, "lisi" -> 20)
      def gredeTest(name:String): Unit ={
        val getGred = b.get(name)
        getGred match{
          case Some(getGred) => println("this some")
          case None => println("this None")
        }
      }
      gredeTest("PK")
      gredeTest("lisi")
      gredeTest("wangwu")
    
第七章
    字符串高级操作：
        多行：借助于s"$常量或$变量" 进行打印
          val a = "Hello"
          val b = "World"
          val c = s"$a $b!"
          println(c)
            使用""""""进行多行打印 Shift + "" 按3次
          val a1 =
            """
              |Hello
              |Wolrd
              |!
            """.stripMargin
          println(a1)
    匿名函数：匿名函数没有函数名，可以赋值给变量或常量或匿名函数
        val a = (x:Int) => x+1  a(10)  结果：11
        val add = (x:Int, y:Int) => x + y  add(2,3) 结果：5
    柯里化：将原来接收多个参数的函数变换成接收一个单一的参数
    高阶函数：
        Map：Map(x => （x,1）)  可以把数据进行Tuple（key-value）操作、柯里化
        filter:根据条件过滤数据
        faltten:将数据进行shuffle， 
            val l = List(List(1,2), List(3,4))
            l.flatten
            结果：List[Int] = List(1, 2, 3, 4)
        FlatMap：结合了flatten和map的特点
        reduce：数据进行计算，例如加法：reduce(_+_)
            reduceLeft、reduceRight 从左或右开始计算
        fold: 数据进行计算，可以再进行单独加一些数据，例如加法，累加后额外再加1：reduce(1)(_+_)
            foldLeft、foldRight 数据进行计算，例如加法：reduce(_+_)
        foreach：循环遍历与for循环类似
    偏函数：{}内的没有match的一组case语句可以进行模式匹配
     //PartialFunction[String, String] 偏函数特征[输入参数,输出参数]
      def moshi:PartialFunction[String, String] = {
        case "wangwu" => "王五"
        case "lisi" => "李四"
        case _ => "None"
      }
      println(moshi("wangwu"))
      
第八章
    隐士转换：通过implicit进行隐士转换，最好把隐士转换都放到一个类里面，方便调用------------面试重点
         implicit def manToSuperMan(man: Man):SuperMan = new SuperMan(man.name)
          val superMan = new SuperMan("lisi")
          superMan.fly()

        class Man(val name:String){
          def eat(): Unit ={
            println(s"$name  is eat.....")
          }
        }

        class SuperMan(val name:String){
          def fly(): Unit ={
            println(s"$name is fly ......")
          }
        }
    隐士参数：对参数增加implicit
      def testParam(implicit name:String){
        println(name + "====================")
      }
      implicit val name = "zhangsan"
      testParam
     隐士类：对类增加implicit
     implicit class classTest(x:String){
        def add(a:Int) = a + x
      }
      println("12345".length)

第九章
    读取文件：Source.fromFIle(文件路径)(文件编码可以不写)，getLines整行读取
    读取MySQL数据：classOf[com.mysql.jdbc.Driver]
    读取XML：this.getClass.getClassLoader.getResource("xml文件")
        \  某一层
        \\ 所有