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

超、凢脫俗 2022-05-11 04:33 204阅读 0赞

学习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文件")  
        \\  某一层  
        \\\\ 所有