<tfoot id='3iyk2tf5'></tfoot><legend id='cz2zz2in'><style id='jyhea907'><dir id='x6dx5hk5'><q id='cauhps5l'></q></dir></style></legend>

      <small id='ubjquh6x'></small><noframes id='cf0azdd5'>

      <i id='dpcxrors'><tr id='0so7itru'><dt id='mes6g0pr'><q id='vfrniis7'><span id='g2mtx5cg'><b id='qcoyvpwx'><form id='q9xflzyw'><ins id='g2psoreq'></ins><ul id='py1gbi4i'></ul><sub id='6whr5aba'></sub></form><legend id='6gvokp0m'></legend><bdo id='u68xafay'><pre id='gx5c1vs6'><center id='onqr4s59'></center></pre></bdo></b><th id='14a6dfbg'></th></span></q></dt></tr></i><div id='o5nku83s'><tfoot id='7n04kn1i'></tfoot><dl id='yfjzbiyo'><fieldset id='u0aftmgb'></fieldset></dl></div>
          <tbody id='rwvhtzxi'></tbody>
      1. 网站建设公司当前位置 : 网站建设公司 > 知识普及

        Scala编程语言学习总结

        发布时间:2021-09-05 21:08   浏览次数:次   
        一、Scala的简介
              Scala是一种基于JVM的编程语言,学习目的主要是为了Spark的学习与相关代码的编写。
            Scala的六大特征:
         
                1).Java和scala可以无缝混编,都是运行在JVM上的
        2).类型推测(自动推测类型),不用指定类型  
        3).并发和分布式(Actor,类似Java多线程Thread) 
        4).特质trait,特征(类似java中interfaces 和 abstract结合)
        5).模式匹配,match case(类似java switch case)
        6).高阶函数(函数的参数是函数,函数的返回是函数),可进行函数式编程
        1
        2
        3
        4
        5
        6
        二、Scala安装使用
        windows安装,配置环境变量
        官网下载scala2.10:https://www.scala-lang.org/download/2.10.4.html
         
        下载好后安装。双击msi包安装,记住安装的路径。
         
        配置环境变量(和配置jdk一样)
                 ①新建SCALA_HOME,配置好Scala安装的目录位置信息。
                 ②编辑Path变量,在后面追加如下:
                   ;%SCALA_HOME%\bin;%SCALA_HOME%\jre\bin
         
        打开cmd,输入:scala - version 看是否显示版本号,确定是否安装成功
         
         
        Scala程序编译工具
            ①Scala ide
             下载网址:http://scala-ide.org/download/sdk.html
            ②推荐使用IDEA中配置scala插件
             1》 打开idea项目后,点击Configure->Plugins
             2》搜索scala,点击Install安装
             3》设置jdk,打开Project Structure,点击new 选择安装好的jdk路径
             4》创建scala项目,配置scala sdk(Software Development Kit)
         
        三、Scala基础
        1.数据类型
         
        2.变量和常量的声明
            Scala中通常用var声明变量,可修改;用val声明常量,不可修改即不可对常量进行再赋值;不用指定数据类型,由Scala自己进行类型推测。
        注意点: 在scala中每行后面不需要加分号,直接通过换行如来区分;但是一行中写了多个语句,语句与语句之间必须用分号来分割
        例如:
         
        var age = 18   ; var name = "angelababy"
            
            var heighat,score = 10
            val sex = "male"
        1
        2
        3
        4
        3.类和对象
         
        class :修饰的称为伴生类;定义在class中的属性都是动态的,用于实例化 的;scala中的class类默认可以传参数,默认的传参数就是默认的构造函数。class 类属性自带getter ,setter方法。使用class时要new (必须new,除非在对象伴生用apply方法【在加载类的时候默认自动调用】已实经例化好),并且new的时候,class中除了方法不执行,其他都执行。
         
        object: 修饰的称为伴生对象;定义在object中的属性(字段、方法)都是静 态的,main函数写在里面;scala 中的object是单例对象,相当于java中的工具类,可以看成是定义静态的方法的类.object不可以传参数。使用object时,不用new.
         
        创建类
         
        class Person{
          val name = "zhangsan"
          val age = 18
          def sayName() = {
            "my name is "+ name
          }
        }
        1
        2
        3
        4
        5
        6
        7
            在创建类时,可以在类名后面加入一个括号,括号中写定义的参数类型,括号中的参数就表示类的构造函数由括号内的参数组成。补充: ①当参数用var修饰那么可以通过对象修改其值;当参数用val修饰那么无法通过对象来修改值;当参数没有修饰符,那么在外部无法通过对象来调用。
              ②若想增加一个类的传入参数,则需要在声明的类中重写构造函数,这样就可以在mian函数中声明有增加的属性的对象,当然原来的对象也可以声明。
                       重写this函数:
         
          /*
           *  重写的构造函数,参数不能有修饰符
           */
          def this (id:Int,name:String,facePower:Double ){
            //首先要调用父构造函数
            this(id,name)
            fcp = facePower
            
          }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        创建对象
         
        object Lesson_Class {
           def main(args: Array[String]): Unit = {
            val person = new Person()
            println(person.age);
            println(person.sayName())
          }
        }
        1
        2
        3
        4
        5
        6
        7
        Apply方法
               使用此方法时,可以在main函数中不通过new来创建一个对象,即可以不用专门的一次一次地进行实例化,加载创建对象的这个类的时候,会自动调用apply这个方法,类似Java中的static静态块。
               Apply方法的使用用例:
         
        object ScalaDemo01 {
          def main(args: Array[String]): Unit = {
            val p = new Person("zs",19)
             val person = Person("wagnwu",10)   //不用使用new来创建一个实例
          }
        }
         
        class Person(xname :String , xage :Int){
          val name = "zs"
          val age = xage
          var gender = "m"
          def this(name:String,age:Int,g:String){
            this(name,age)
            gender = g
          }
        }
         
        object Person{
          def apply(name:String,age:Int)={
            new Person(name,age)  
          }
        }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        4.if{…}else{…}语句
         
            /**
             * if else 
             */
            val age =18 
            if (age < 18 ){
            println("no allow")
            }else if (18<=age&&age<=20){
            println("allow with other")
            }else{
            println("allow self")
            }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        5.for ,while,do…while
            ①to和until 的用法(不带步长,带步长区别)
         
         /**
             * to和until
             * 例:
             * 1 to 10 返回1到10的Range数组,包含10
             * 1 until 10 返回1到10 Range数组 ,不包含10
             */
            
            println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
            
            println(1 to (10 ,2))//步长为2,从1开始打印 ,1,3,5,7,9
            
            println(1 until 10 ) //不包含最后一个数,打印 1,2,3,4,5,6,7,8,9
            
            println(1 until (10 ,3 ))//步长为2,从1开始打印,打印1,4,7
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
            ②for循环(可加判断条件)
         
            //可以分号隔开,写入多个list赋值的变量,构成多层for循环
            //scala中 不能写count++ count-- 只能写count+
            //可以在for循环中加入条件判断
            var count = 0;
            for(i <- 1 to 10; j <- 1 until 10;if (i%2) == 0){
              println("i="+ i +",j="+j)
              count += 1
            }
            println(count);
            
            //例子: 打印小九九
            for(i <- 1 until 10 ;j <- 1 until 10){
              if(i>=j){
              print(i +" * " + j + " = "+ i*j+" ")  
              }
              if(i==j ){
                println()
              }
            }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        补充: for循环用yield 关键字返回一个集合
         
        /*
         *  yield 关键字
         *  1-100集合中的偶数存储到另一个集合
         *  yield关键字能够将符合要求的元素自动封装到一个集合中
         */
        val rest = for(i <- 1 to 100; if i%2 == 0) yield i     //此时rest就为选择出的i构成的一个集合
        for(elem <- rest) println(elem)
        1
        2
        3
        4
        5
        6
        7
            ③while循环,while(){},do {}while()
         
           /**
             * while 循环
             */
            var index = 0 
            while(index < 100 ){
            println("第"+index+"次while 循环")
              index += 1 
            }
            index = 0 
            do{
            index +=1 
            println("第"+index+"次do while 循环")
        }while(index <100 )
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        6.函数
            ①普通函数
         
        def fun (a: Int , b: Int ) : Unit = {
           println(a+b)
         }
        fun(1,1)
            
        def fun1 (a : Int , b : Int)= a+b
            println(fun1(1,2))  
        1
        2
        3
        4
        5
        6
        7
            ②递归函数
         
         /**
             * 递归函数 
             * 5的阶乘
             */
            def fun2(num :Int) :Int= {  //必须写返回值类型
              if(num ==1)
                num
              else 
                num * fun2(num-1)
            }
            print(fun2(5))
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
            ③包含参数默认值的函数
         
         /**
           * 包含参数默认值的函数
           * 1. 函数的参数有默认值,在调函数的时候可以传参,也可以不传参,
           * 2. 若不传参使用的默认值,
           * 3. 如果传参,默认值会被覆盖
           */
          def fun2(num1:Int = 10,num2:Int = 20) = {
            num1 + num2
          }
          
          def fun3(num1:Int,num2:Int = 20) = {
            num1 + num2
          }
          
          def fun4(num1:Int=10,num2:Int) = {
            num1 + num2
          }
          调用:
           println(fun2())
           println(fun3(100))
           println(fun4(num2=1000))
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
            ④可变参数个数的函数:函数参数可以是一个也可以是多个,随机灵活的
         
         def fun5(args:Double*) = {
            /**
             * 在scala中
             * +=前后的数值类型必须一致
             * +前后的数值类型可以不一致
             */
            var sum = 0.0
            for(arg <- args) sum += arg
            sum
          }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
            ⑤匿名函数:没有函数名的函数
         
        /**
         * 匿名函数
         * 1.有参数匿名函数
         * 2.无参数匿名函数
         * 3.有返回值的匿名函数
         * 注意:
         * 可以将匿名函数返回给定义的一个变量
         * 匿名函数不能显式声明函数的返回类型
         
         */
        //有参数匿名函数
        val value1 = (a : Int) => {
          println(a)
        }
        value1(1)
        //无参数匿名函数
        val value2 = ()=>{
          println("我爱Angelababy")
        }
        value2()
        //有返回值的匿名函数
        val value3 = (a:Int,b:Int) =>{
          a+b
        }
        println(value3(4,4)) 
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
            ⑥嵌套函数
         
            /**
             * 嵌套函数:
             * 在函数体内有定义了一个函数
             */
            def fun7(num:Int)={
              def fun8(a:Int,b:Int):Int={
                if(a == 1){
                  b
                }else{
                  fun8(a-1,a*b)
                }
              }
              fun8(num,1)
            }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
            ⑦偏应用函数:偏应用函数是一种表达式,不需要提供函数需要的所有参数,只需要提供部分,或不提供所需参数。在多个函数调用时,有共同的参数被使用,则可提取出来默认写死,只需要为函数提供部分的参数。
         
        /**
         * 偏应用函数
         */
        def log(date :Date, s :String)= {
          println("date is "+ date +",log is "+ s)
        }
         
        val date = new Date()
        log(date ,"log1")
        log(date ,"log2")
        log(date ,"log3")
         
        //想要调用log,以上变化的是第二个参数,可以用偏应用函数处理
        val logWithDate = log(date,_:String)    //下划线相当于占位符的作用,手动传入即可
        logWithDate("log11")
        logWithDate("log22")
        logWithDate("log33")
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
            ⑧ 高阶函数:函数的参数是函数,或者函数的返回类型是函数,或者函数的参数和函数的返回类型是函数的函数。
         
         //函数的参数是函数
            def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
              f(a,100)
            }
            def f(v1 :Int,v2: Int):Int  = {
              v1+v2
            }
            
            println(hightFun(f, 1))
            
            //函数的返回是函数
            //1,2,3,4相加
            def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
              def f2 (v1: Int,v2:Int) :Int = {
                v1+v2+a+b
              }
              f2
            }
            println(hightFun2(1,2)(3,4))
            
            //函数的参数是函数,函数的返回是函数
            def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
              f
            } 
            println(hightFun3(f)(100,200))
            println(hightFun3((a,b) =>{a+b})(200,200))
            //以上这句话还可以写成这样
            //如果函数的参数在方法体中只使用了一次 那么可以写成_表示
            println(hightFun3(_+_)(200,200))
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
            ⑨柯里化函数
         
            /**
               * 柯里化函数
               * 可以理解为高阶函数的简化
               * klhFun函数就是对嵌套函数这种情况的高阶函数的简化版
               */
         
              def klhFun(a:Int)(b:Int) = a*b
              具体:
              def klhAllFun(a:Int):(Int)=>Int = {
                val fun = (b:Int)=>a*b
                fun
              }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        7.Scala字符串
         
        val str1 = "hello bi"
            val str2 = "hello sh"
            val flag = str1.equalsIgnoreCase(str2)    
            println(flag)
            
            str1.split(" ")
         
            val strBuilder = new StringBuilder
            strBuilder.append("hello\t")
            strBuilder.append("bj")
            println(strBuilder)
            println("hello Angelababy".hashCode())
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        string操作方法举例
        1.比较:equals
        2.比较忽略大小写:equalsIgnoreCase
        3.indexOf:如果字符串中有传入的assci码对应的值,返回下标
         
          /**
             * String && StringBuilder
             */
            val str = "abcd"
            val str1 = "ABCD"
            
            println(str.indexOf(97))
            println(str.indexOf("b"))
         
            println(str==str1)
            /**
             * compareToIgnoreCase
             * 
             * 如果参数字符串等于此字符串,则返回值 0;
             * 如果此字符串小于字符串参数,则返回一个小于 0 的值;
             * 如果此字符串大于字符串参数,则返回一个大于 0 的值。
             * 
             */
            println(str.compareToIgnoreCase(str1))
            
            val strBuilder = new StringBuilder
            strBuilder.append("abc")
        //    strBuilder.+('d')
            strBuilder+ 'd'
        //    strBuilder.++=("efg")
            strBuilder++= "efg" 
        //    strBuilder.+=('h')
            strBuilder+= 'h' 
            strBuilder.append(1.0)
            strBuilder.append(18f)
            println(strBuilder)
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        8.数组
         
         //数组  new String[10]
            /**
             * Array关键词 创建一个长度为10 的Int类型的数组
             * 如果创建了一个Int类型的数组,那么初始值都是0
             * String类型的数组,初始是null
             * Boolean类型的数组,初始是false
             */
            val nums = new Array[Int](10)
            for(index <- 0 until nums.length){
              nums(index) = index * index
            }
            nums.foreach {println }
            
            //二维数组
            val secArray = new Array[Array[String]](10)
            for(index <- 0 until secArray.length){
              secArray(index) = new Array[String](10)
            }
            
            //往二维数组中填充数据    
           /* for(i <- 0 until secArray.length){
              for(j <- 0 until secArray(i).length){
                secArray(i)(j) = i*j + ""
              }
            }*/
            for(i <- 0 until secArray.length;j <- 0 until secArray(i).length){
              secArray(i)(j) = i*j + ""
            }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        9.List集合
         
           /**
            * list集合
            * 
            * list集合是一个不可变的集合
            * 可变的list集合
            */
            println("=========List==========")
            val list = List(1,2,3,4,5)
            list.contains(6)
            val dropList = list.drop(2)
            dropList.foreach { println }
            list.reverse
            list.take(3).foreach(println)
            val mapList1 = list.map { x=> x +"" }
            mapList1.foreach { x=>println(x) }
            println(list.exists { x => x > 300 })
            println(list.mkString("\t"))
            
            val logList = List("hello bj","hello sh")
            val mapList = logList.map { _.split(" ") }
        //    mapList.foreach { x => x.foreach { println } }
            //flatMap方法   flat扁平 
            val flatMapList = logList.flatMap{_.split(" ")}
            flatMapList.foreach { println }
         
        /**
             * 不可变的list集合
             * 创建list集合的方式:
             * 1、List(1,2,3)
             * 2、Nil关键创建  Nil:空List
             * ::往集合中添加元素
             */
            val list = 2::1::Nil
            
            /**
             * 可变的list集合
             */
            val listBuffer = new ListBuffer[String]
            listBuffer.+=("hello")
            listBuffer.+=("bj")
            listBuffer.foreach { println }
            
            listBuffer.-=("hello")
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        10.set集合
         
           //创建 
            val set1 = Set(1,2,3,4,4)
            val set2 = Set(1,2,5)
            //遍历
            //注意:set会自动去重
            set1.foreach { println}
           for(s <- set1){
              println(s)
            }
            println("*******")
           /**
            * 方法举例
            */
            
           //交集
           val set3 = set1.intersect(set2)
           set3.foreach{println}
           val set4 = set1.&(set2)
           set4.foreach{println}
           println("*******")
           //差集
           set1.diff(set2).foreach { println }
           set1.&~(set2).foreach { println }
           //子集
           set1.subsetOf(set2)
           
           //最大值
           println(set1.max)
           //最小值
           println(set1.min)
           println("****")
           
           //转成数组,list
           set1.toArray.foreach{println}
           println("****")
           set1.toList.foreach{println}
           
           //mkString
           println(set1.mkString)
           println(set1.mkString("\t"))
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        11.Map集合
         
         val map = Map(
                          "1" -> "bj",
                          2 -> "sh",
                          3 -> "gz"
                        )
            val keys = map.keys
            val keyIterator = keys.iterator
            while(keyIterator.hasNext){
              val key = keyIterator.next()
              /**
               * map集合的get方法返回值是一个Option类型的对象
               * Option类型有两个子类型  分别为some None
               */
               Map中的方法 :
               1. filter:过滤,留下符合条件的记录
               2. count:统计符合条件的记录数
               3. contains:map中是否包含某个key
               4. exist:符合条件的记录存在不存在
         
              println(key + "\t" + map.get(key).get)
            }
             
             /**
              * getOrElse 原理:
              * 去集合中去取数据,若不存在返回默认值
              */
             println(map.get(4).getOrElse("default"))
            
             for(k <- map)
               println(k._1 + "\t" + k._2)     //分别取第一个位置的数据和第二个位置的数据,即Key-Value
               
             map.foreach(x=>println(x._1 + "\t" + x._2))    
             
             
             map.filter(x=>{
               Integer.parseInt(x._1 + "") >= 2
             }).foreach(println)
             
             val count = map.count(x=>{
               Integer.parseInt(x._1 + "") >= 2
             })
             println(count)
             
             /**
             合并Map的操作:
             1.++  例:map1.++(map2)  --map1中加入map2
             2.++:  例:map1.++:(map2) –map2中加入map1
             注意:合并map会将map中的相同key的value替换
             **/
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        44
        45
        46
        47
        48
        49
        12.元组
         
         /**
              * 元组 vs list
              * list创建的时候指定了泛型,那么集合中必须是这个泛型的对象
              * 元祖中可以包含任意类型的元素,这些元素使用一对小括号来封装,Tuple关键字
              * 
              * 
              */
             val t2 = Tuple2(1,"hello")
             val tt2 = (1,"hello")
             
             val t3 = Tuple3(1,true,"hello")  //可以存放Int、boolean、String多种不同的类型
             val tt3 = (1,true,"hello")
             
             val moreTuple = (1,2,3)   
             
              val tupleIterator = tt3.productIterator    //元组的遍历
              while(tupleIterator.hasNext){
              println(tupleIterator.next())
            }
             //toString方法
             println(tt3.toString())
             //swap交换    注意只有二元组对象才会有这个方法
             val swapt2 = tt2.swap
             println(swapt2._1 + "\t" + swapt2._2)
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        13.Trait特性
               ①Trait的概念理解
        1》 Scala Trait(特征) 相当于 Java 的接口,实际上它比接口还功能强大。
        2》与接口不同的是,它还可以定义属性和方法的实现。抽象类和接口的结合。
        3》一般情况下Scala的类可以继承多个Trait,从结果来看就是实现了多重继承。Trait的继承用exten关键字继承,多继承时多个Trait之间用with连接。
        4》Trait(特征) 定义的方式与类类似,但它使用的关键字是 trait。
        5》继承的多个trait中如果有同名的方法和属性,必须要在类中使用“override”重新定义。
        6》trait中不可以传参数
         
        trait Read {
          val readType = "Read"
          val gender = "m"
          def read(name:String){
        println(name+" is reading")
          }
        }
         
        trait Listen {
          val listenType = "Listen"
          val gender = "m"
          def listen(name:String){
        println(name + " is listenning")
          }
        }
         
        class Person() extends Read with Listen{
          override val gender = "f"
        }
         
        object test {
          def main(args: Array[String]): Unit = {
            val person = new Person()
            person.read("zhangsan")
            person.listen("lisi")
            println(person.listenType)
            println(person.readType)
            println(person.gender)
            
          }
        }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        14.模式匹配Match…Case…
              ①概念理解
        =>Java中的模式匹配为 switch case ;
        =>Scala 提供了强大的模式匹配机制,应用也非常广泛,除了匹配值还可以匹配类型,类型的匹配必须要有变量名。
        =>一个模式匹配包含了一系列备选项,每个都开始于关键字 case。
        =>每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。
         
        object Lesson_Match {
          def main(args: Array[String]): Unit = {
            val tuple = Tuple6(1,2,3f,4,"abc",55d)
            val tupleIterator = tuple.productIterator
            while(tupleIterator.hasNext){
              matchTest(tupleIterator.next())
            }
            
          }
          /**
           * 注意点:
           * 1.模式匹配不仅可以匹配值,还可以匹配类型
           * 2.模式匹配中,从上到下顺序匹配,如果匹配到对应的类型或值,就不再继续往下匹配
           * 3.模式匹配中,都匹配不上时,会匹配到 case _ ,相当于default
           * 4. 模式匹配的时候,模式范围小的在最前面
           */
          def matchTest(x:Any) ={
            x match {
              case x:Int=> println("type is Int")    //类型匹配,必须要有变量名
              case 1 => println("result is 1")
              case 2 => println("result is 2")
              case 3=> println("result is 3")
              case 4 => println("result is 4")
              case x:String => println("type is String")
        //      case x :Double => println("type is Double")
              case _ => println("no match")
            }
          }
        }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        15.样例类(case class)
             ①概念理解
               使用了case关键字的类定义就是样例类(case classes),样例类是种特殊的类。实现了类构造参数的getter方法(构造参数默认被声明为val),当构造参数是声明为var类型的,它将帮你实现setter和getter方法。
               样例类默认帮你实现了toString,equals,copy和hashCode等方法。
               样例类可以new, 也可以不用new
         
        /**
              * 样例类
              * 使用case 来修饰的类就叫样例类
              * 
              * 样例类和普通类有什么区别?
              * 样例类默认帮你实现了toString,equals,copy和hashCode等方法。
        样例类可以new, 也可以不用new 
              */
             val s1 = Student(1,1)
             val s2 = Student(2,2)
             val s3 = Student(3,3)
             val s4 = Student(4,4)
             val s5 = Student(5,5)
             
             val sl = List(s1,s2,s3,s4,s5)
             //样例类+match case
             sl.foreach { x => x match {
               case Student(1,1) => println("1 1")    //值匹配,且使用了样例类已经写好了的toString方法。
               case s:Student => println("Student" + s)    //类型匹配
               case _ => println("_______")
             } }
          } 
        }
        //样例类
        case class Student(val id :Int ,val age :Int)
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        16.Actor Model
             ①概念理解
                 Actor Model是用来编写并行计算或分布式系统的高层次抽象(类似java中的Thread)让程序员不必为多线程模式下共享锁而烦恼,被用在Erlang 语言上, 高可用性99.9999999 % 一年只有31ms 宕机Actors将状态和行为封装在一个轻量的进程/线程中,但是不和其他Actors分享状态,每个Actors有自己的世界观,当需要和其他Actors交互时,通过发送事件和消息,发送是异步的,非堵塞的(fire-andforget),发送消息后不必等另外Actors回复,也不必暂停,每个Actors有自己的消息队列,进来的消息按先来后到排列,这就有很好的并发策略和可伸缩性,可以建立性能很好的事件驱动系统。
         
        Actor的特征:
        1.ActorModel是消息传递模型,基本特征就是消息传递
        2.消息发送是异步的,非阻塞的
        3.消息一旦发送成功,不能修改,类似于邮件的发送来往
        4.Actor之间传递时,自己决定决定去检查消息,而不是一直等待,是异步非阻塞的
         
        //Actor与Actor之间通信
        case class Message(actor:Actor,msg:Any)
         
        class Actor1 extends Actor{
          def act(){
            while(true){
              receive{
                case  msg :Message => {      //类型匹配
                  println("i sava msg! = "+ msg.msg)
                  
                  msg.actor!"i love you too !"
                  }
                case msg :String => println(msg)
                case  _ => println("default msg!")
              }
            }
          }
        }
         
        class Actor2(actor :Actor) extends Actor{
          actor ! Message(this,"i love you !")
        def act(){
        while(true){
        receive{
          case msg :String => {
            if(msg.equals("i love you too !")){
              println(msg)
             actor! "could we have a date !"
            }
          }
          case  _ => println("default msg!")
        }
        }
        }
        }
         
        object Lesson_Actor2 {
          def main(args: Array[String]): Unit = {
            val actor1 = new Actor1()
            actor1.start()
            val actor2 = new Actor2(actor1)
            actor2.start()
          }
        }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        44
        17.Scala的隐式转换系统
                隐式转换,在编写程序的时候可以尽量少的去编写代码,让编译器去尝试在编译期间自动推导出这些信息来,这种特性可以极大的减少代码量,提高代码质量.
            ①隐式值+隐式视图
        通过implicit进行隐式的声明
         
          object Scala09 {
          def main(args: Array[String]): Unit = {
        //隐式值:
        //  implicit var abc = "Dilireba"
            implicit var cba = "Angelababy"
            sayName   //直接调用,不用传参 
          /* 将变量声明为implicit,编译器在执行sayName方法时发现缺少一个String类型的参数,
              此时会搜索作用域内类型为String的隐式值
              并且将搜索到的隐式值作为sayName的参数值
           */
         
            
            //    1.隐式转换必须满足无歧义规则
            //    2.声明隐式参数的类型最好是自定义的数据类型,
            //    3.不要使用Int,String这些常用类型,防止碰巧冲突
            //    4.一般要将自定义的对象设置为隐式的
            
            //  隐式视图  --》隐式转换为目标类型:把一种类型自动转换到另一种类型
            implicit def string2Int(num:String) = Integer.parseInt(num) 
         
            //addNum参数是tring,不符合要求,那么他在编译的时候,发现作用域内
            //    有一个隐式方法,正好这个方法的参数是String 返回值是Int  此时
            //调用隐式方法,返回一个Int值,在将Int传给addNum
         
            println(addNum("1000"))
         
          }
          
          
          def addNum(num:Int) = {
              num + 1000
            }
          
          def sayName(implicit name:String) = {
            println("I Love " + name)
          }
          
        }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
            ②隐式类
         
           注意点:
            1.其所带的构造参数有且只能有一个
            2.隐式类必须被定义在类,伴生对象和包对象里
            3.隐式类不能是case class(case class在定义会自动生成伴生对象与2矛盾)
            4.作用域内不能有与之相同名称的标示符
            
        package com.hpe.scala
         
        object Scala10 {
          def main(args: Array[String]): Unit = {
            //  隐式类   导包要从包名开始
            import com.hpe.scala.Util._     //Util下的所有类
            "abc".getLength()
            /**
             * "abc"这个字符串想要调用getLength,但是自己没有实现这个方法
             * 发现作用域内有一个隐式转换的类,类的构造函数的参数是String类型
             * 自己传给构造函数,得到这个类的对象,近而调用getLength方法
             */
          }
        }
         
        object Util{
          implicit class Int2String(s:String){
            def getLength() = s.length
          }
        }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        补充点:“_”在scala中的意义
         
        _表示所有 、2.占位符、3.简写模式
         
            • <legend id='aygrvvzm'><style id='ar98wnk8'><dir id='my95kk8w'><q id='q5msrlt2'></q></dir></style></legend>

              <small id='j810paso'></small><noframes id='7sj01zg9'>

                <tbody id='tioo4wkb'></tbody>
              <tfoot id='mkdxj5wa'></tfoot>
            • <i id='x5ekonk4'><tr id='0x353odw'><dt id='pzpkrkk6'><q id='gxtarfho'><span id='udwrhrk9'><b id='tzsldhcy'><form id='rwrqtf6h'><ins id='2kg74br8'></ins><ul id='8vr5nedo'></ul><sub id='n1hgbfqq'></sub></form><legend id='ecvp1bj5'></legend><bdo id='00ck6l76'><pre id='saiorqbt'><center id='nvyuvkln'></center></pre></bdo></b><th id='srr4zu6n'></th></span></q></dt></tr></i><div id='f1shh6ip'><tfoot id='u3bucluk'></tfoot><dl id='5jekprz4'><fieldset id='2q3tt2ar'></fieldset></dl></div>

              本文来源于网络,若有侵权请联系3449817223#qq.com,将在第一时间删除。

              上一篇:Scala语言基础 小程序开发上一篇

                <i id='j7gk7rgh'><tr id='o9n5m1w7'><dt id='o7n98spv'><q id='v81hjc64'><span id='mfrewaax'><b id='53q4l86t'><form id='rij1m4w4'><ins id='1mnakngz'></ins><ul id='7fpdkdwe'></ul><sub id='u7fdic5k'></sub></form><legend id='kn04345j'></legend><bdo id='2qugocwt'><pre id='hqswm713'><center id='2xj1zrid'></center></pre></bdo></b><th id='f8fnuqz1'></th></span></q></dt></tr></i><div id='ncwtleuo'><tfoot id='bcqz26fy'></tfoot><dl id='05mma4ic'><fieldset id='dakuvise'></fieldset></dl></div>
                  <tbody id='ajz0n67d'></tbody>

                  <tfoot id='dw8nm6nt'></tfoot>

                  <small id='s78pxuhg'></small><noframes id='qep338ct'>

                  <legend id='x01cleoj'><style id='cyyw33ns'><dir id='yv6yoh1e'><q id='2be94nz9'></q></dir></style></legend>