Scala教程

阳光穿透心脏的1/2处 2022-03-17 13:16 204阅读 0赞

**目录：**

1.  入门：[Scala教程][Scala]
2.  进阶：Java集合与scala集合互操作
3.  高阶函数

**内容：**

1.  入门
    
    1.  Scala概述
        
        1.  Scala是面向对象语言  
            Scala是一种纯粹的面向对象语言，每一个值都是一个对象。
        2.  Scala是函数式编程语言  
            Scala也是一种函数式语言，每个函数都是一个值，每个值都是一个对象，所以每个函数都是一个对象。
        3.  Scala运行在JVM上   
            Scala代码被编译成由Java虚拟机(JVM)执行的Java字节代码，这意味着Scala和Java具有通用的运行时平台。
    2.  Scala开发环境安装配置
    3.  Scala基础语法  
        Scala和Java之间最大的句法差异在于行结束字符的分号(`;`) 是可选的。
    4.  Scala数据类型
    5.  Scala变量
    6.  Scala访问修辞符
    7.  Scala运算符
    8.  Scala循环语句
    9.  Scala函数：  
        Scala函数是Scala编程的核心，因此Scala被认为是函数式编程语言。
    10. Scala闭包  
        闭包是一个函数，它返回值取决于在此函数之外声明的一个或多个变量的值。
    11. Scala字符串
    12. Scala数组
    13. Scala集合
    14. Scala模式匹配
    15. Scala正则表达式
    16. Scala异常处理
    17. Scala提取器
    18. Scala文件I/O
2.  面向对象和概念
    
    1.  Scala类和对象
    2.  Scala单例和伴生对象
    3.  Scala Case类和对象
    4.  Scala构造函数
    5.  Scala方法重载
    6.  Scala this关键字
    7.  Scala方法覆盖
    8.  Scala final关键字
3.  进阶：Java集合与scala集合互操作：参考scala.collection.JavaConversions中有哪些集合可以进行互操作
    
    1.  scala.collection.Iterable <=> java.lang.Iterable
    2.  scala.collection.Iterable <=> java.util.Collection
    3.  scala.collection.Iterator <=> java.util.\{ Iterator, Enumeration \}
    4.  scala.collection.mutable.Buffer <=> java.util.List
        
            //比如把Java的list快速转为scala的buffer
            val scalaList = JavaConversions.asScalaBuffer(javaList)
    5.  scala.collection.mutable.Set <=> java.util.Set
    6.  scala.collection.mutable.Map <=> java.util.\{ Map, Dictionary \}
    7.  scala.collection.mutable.ConcurrentMap <=> java.util.concurrent.ConcurrentMap
    8.  scala.collection.Seq  => java.util.List
    9.  scala.collection.mutable.Seq => java.util.List
    10. scala.collection.Set  => java.util.Set
    11. scala.collection.Map => java.util.Map
    12. java.util.Properties => scala.collection.mutable.Map\[String, String\]
    13. 示例：propertiesAsScalaMap
        
            object Test{
              def main(args: Array[String]): Unit = {
                import scala.collection.JavaConversions.propertiesAsScalaMap
                val sysPros:scala.collection.mutable.Map[String,String]=System.getProperties
                for((k,v) <- sysPros){
                  println("K:"+k+"------"+"V:"+v)
                }
              }
              
            }
            
            打印结果：
            K:java.runtime.name------V:Java(TM) SE Runtime Environment
            K:sun.boot.library.path------V:E:\softs\Java\jdk1.8.0_121\jre\bin
            K:java.vm.version------V:25.121-b13
            K:java.vm.vendor------V:Oracle Corporation
            K:java.vendor.url------V:http://java.oracle.com/
            K:path.separator------V:;
            K:java.vm.name------V:Java HotSpot(TM) 64-Bit Server VM
            K:file.encoding.pkg------V:sun.io
            K:user.country------V:CN
            K:user.script------V:
            K:sun.java.launcher------V:SUN_STANDARD
            K:sun.os.patch.level------V:Service Pack 1
            K:java.vm.specification.name------V:Java Virtual Machine Specification
            K:user.dir------V:E:\tools\Eclipse\scala-workspace\hello
            K:java.runtime.version------V:1.8.0_121-b13
            K:java.awt.graphicsenv------V:sun.awt.Win32GraphicsEnvironment
            K:java.endorsed.dirs------V:E:\softs\Java\jdk1.8.0_121\jre\lib\endorsed
            K:os.arch------V:amd64
            K:java.io.tmpdir------V:C:\Users\ADMINI~1.PC-\AppData\Local\Temp\
            K:line.separator------V:
            
            K:java.vm.specification.vendor------V:Oracle Corporation
            K:user.variant------V:
            K:os.name------V:Windows 7
            K:sun.jnu.encoding------V:GBK
            K:java.library.path------V:E:\softs\Java\jdk1.8.0_121\bin;C:\Windows\Sun\Java\bin;C:\Windows\system32;C:\Windows;C:/Program Files/Java/jre1.8.0_201/bin/server;C:/Program Files/Java/jre1.8.0_201/bin;C:/Program Files/Java/jre1.8.0_201/lib/amd64;E:\tools\Xftp-6\;E:\tools\Xshell-6\;C:\ProgramData\Oracle\Java\javapath;C:\Program Files (x86)\Common Files\Oracle\Java\javapath;E:\softs\Java\jdk1.8.0_121\bin;E:\softs\Java\jre1.8.0_121;E:\softs\scala\bin;C:\windows\system32\;E:\downloads\mysql\mysql-5.7.21-winx64\bin;E:\softs\zookeeper-3.4.12\bin;E:\downloads\maven\bin;E:\tools\Git\cmd;E:\tools\Eclipse\eclipse\dropins\eclipse;;.
            K:java.specification.name------V:Java Platform API Specification
            K:java.class.version------V:52.0
            K:sun.management.compiler------V:HotSpot 64-Bit Tiered Compilers
            K:os.version------V:6.1
            K:user.home------V:C:\Users\Administrator.PC-20190215IDUT
            K:user.timezone------V:
            K:java.awt.printerjob------V:sun.awt.windows.WPrinterJob
            K:file.encoding------V:UTF-8
            K:java.specification.version------V:1.8
            K:java.class.path------V:E:\tools\Eclipse\scala-workspace\hello\bin
            K:user.name------V:Administrator
            K:java.vm.specification.version------V:1.8
            K:sun.java.command------V:test.Test
            K:java.home------V:E:\softs\Java\jdk1.8.0_121\jre
            K:sun.arch.data.model------V:64
            K:user.language------V:zh
            K:java.specification.vendor------V:Oracle Corporation
            K:awt.toolkit------V:sun.awt.windows.WToolkit
            K:java.vm.info------V:mixed mode
            K:java.version------V:1.8.0_121
            K:java.ext.dirs------V:E:\softs\Java\jdk1.8.0_121\jre\lib\ext;C:\Windows\Sun\Java\lib\ext
            K:sun.boot.class.path------V:E:\tools\Eclipse\eclipse\dropins\eclipse\plugins\org.scala-lang.scala-library_2.12.3.v20170725-052526-VFINAL-6ac6da8.jar;E:\tools\Eclipse\eclipse\dropins\eclipse\plugins\org.scala-lang.scala-reflect_2.12.3.v20170725-052526-VFINAL-6ac6da8.jar;E:\softs\Java\jdk1.8.0_121\jre\lib\resources.jar;E:\softs\Java\jdk1.8.0_121\jre\lib\rt.jar;E:\softs\Java\jdk1.8.0_121\jre\lib\sunrsasign.jar;E:\softs\Java\jdk1.8.0_121\jre\lib\jsse.jar;E:\softs\Java\jdk1.8.0_121\jre\lib\jce.jar;E:\softs\Java\jdk1.8.0_121\jre\lib\charsets.jar;E:\softs\Java\jdk1.8.0_121\jre\lib\jfr.jar;E:\softs\Java\jdk1.8.0_121\jre\classes
            K:java.vendor------V:Oracle Corporation
            K:file.separator------V:\
            K:java.vendor.url.bug------V:http://bugreport.sun.com/bugreport/
            K:sun.io.unicode.encoding------V:UnicodeLittle
            K:sun.cpu.endian------V:little
            K:sun.desktop------V:windows
            K:sun.cpu.isalist------V:amd64
        
         
4.  高级
    
    1.  Scala高阶函数
        
        1.  第一级别：作为变量的函数
            
            1.  Scala中，变量不但可以存储数字，字符，对象，还可以存储函数
            2.  Scala的语法规定，将函数赋值给变量时，必须在函数后面加上空格和下划线
            3.  将函数赋值给变量时，函数的参数不需要给定相应的值
            4.  示例：
                
                    object Test{
                      def main(args: Array[String]): Unit = {
                        var aaa=add _
                        println(aaa(2,3))
                      }
                      
                      def add(x:Int,y:Int):Int={
                        x+y
                      }
                    }
                    
                    //打印结果为5
        2.  第二级别：匿名函数
            
            1.  Scala中，函数也可不需要命名，此时函数被称为匿名函数
            2.  可以直接在定义函数之后，将函数赋值给某个变量，也可以直接定义匿名函数传入其它的函数之中
            3.  语法规则：（参数名：参数类型）=>函数体
            4.  示例：
                
                    object Test{
                      def main(args: Array[String]): Unit = {
                        var aaa=(x:Int,y:Int)=>x*y
                        println(aaa(2,3))
                      }
                    }
                    
                    //打印结果为6
        3.  第三级别：带函数参数的函数
            
            1.  Scala中可以将某个函数传入其它函数，作为参数，这个功能是极其强大的
            2.  接收其他函数作为参数的函数，也被称作：高级函数（higher-order function）
            3.  示例：
                
                    object Test{
                      def main(args: Array[String]): Unit = {
                        //创建一个匿名函数，赋值给变量
                        var param=(str:String)=>println("高阶函数传过来的值为:"+str)
                        
                        //调用高阶函数
                        hello(param)
                      }
                      /*
                       * 创建高阶函数
                       * @param x 需要一个参数为String类型
                       */
                      def hello(x:String=>Unit):Unit={
                        x("你好")
                      }
                    }
                    
                    //打印结果为：高阶函数传过来的值为:你好
        4.  第四级别：返回一个函数的函数
            
            1.  高阶函数的另一个功能是将函数作为返回值
            2.  示例：
                
                    object Test{
                      def main(args: Array[String]): Unit = {
                        //创建一个匿名函数，赋值给变量
                        var v1=hello("旧值")
                        v1("新值")
                      }
                      
                      /*
                       * 将函数作为一个返回值
                       */
                      def hello(name:String)={
                        (str:String)=>println("hello方法的值为："+name+"，返回再次调用的值为:"+str)
                      }
                    }
                    
                    //打印结果为:hello方法的值为：旧值，返回再次调用的值为:新值
    2.  柯里化函数
    3.  偏函数
    4.  递归函数
    5.  嵌套函数
    6.  尾递归
    7.  常用高阶函数
        
        1.  foreach也是高阶函数：
            
                object Test{
                  def main(args: Array[String]): Unit = {
                    List(3,4,5,6).foreach(x=>println(x))
                  }
                }
                
                /*打印结果为：
                3
                4
                5
                6
                */
        2.  map高阶函数的使用：
            
                object Test{
                  def main(args: Array[String]): Unit = {
                    //map函数：练习1
                    (1 to 5).map(x => "*"*x).foreach(println)
                    
                    //map函数：练习2
                    Array("无尽"->3200,"饮血"->3000,"多兰戒"->450).map(x => (x._1,x._2/2)).foreach(println)
                    
                    //练习2改进
                    Array("无尽"->3200,"饮血"->3000,"多兰戒"->450).map(mapSale).foreach(println)
                    
                    def mapSale(tuple:Tuple2[String,Int]):Tuple2[String,Int]={
                      new Tuple2[String,Int](tuple._1,tuple._2/2)
                    }
                  }
                }
                
                打印结果：
                *
                **
                ***
                ****
                *****
                (无尽,1600)
                (饮血,1500)
                (多兰戒,225)
                (无尽,1600)
                (饮血,1500)
                (多兰戒,225)
        3.  flatMap高阶函数的使用
            
                import scala.collection._
                object Test{
                  def main(args: Array[String]): Unit = {
                    val list=List("hello keduox","hello java")
                    list.flatMap(_.split(" ")).foreach(println)
                    
                    //map和flatMap的区别
                    list.flatMap(_.split(" ")).foreach(x=>println(x.length))// 5,6,5,4
                    list.map(_.split(" ")).foreach(x => println(x.length)) //2,2
                  }
                }
                
                //打印结果为：
                hello
                keduox
                hello
                java
            
            注意：Map和flatMap的区别
        4.  filter高阶函数的使用
            
                object Test{
                  def main(args: Array[String]): Unit = {
                    Array(1,2,3,4,5,6).filter(x=>x>4).foreach(println)
                  }
                }
                
                打印结果为：
                5
                6
        5.  reduce函数的使用
            
                object Test{
                  def main(args: Array[String]): Unit = {
                    println((1 to 10).reduce((a1,a2)=> a1*a2))
                    println((1 to 10).reduce(_*_))
                    
                    //改进
                    println((1 to 10).reduce(reduceFunction))
                    
                    def reduceFunction(previous:Int,current:Int):Int={
                      previous*current
                    }
                  }
                }
                
                打印结果为：
                3628800
                3628800
                3628800
    8.  练习  
        ![20190224192334380.png][]  
        （1）
        
            object Test{
              def main(args: Array[String]): Unit = {
                //方法一
                val arr =Array(("key1",2),("key2",23),("key3",4),("key4",10)).map(x=>x._2).sum
                println(arr)
                
                //方法二：改进
                val arr2=Array(("key1",2),("key2",23),("key3",4),("key4",10)).map(add).sum
                println(arr2)
            
              }
              def add(tuple:Tuple2[String,Int]):Int={
                  tuple._2
              }
              
            }
            
            
            打印结果：
            39
            39
    9.  练习
        
        1.  编写一个循环，将整数数组中的相邻元素进行置换，例如ARRAY(1,2,3,4,5)经过置换编程ARRAY(2,1,4,3,5)
        2.  重复前一个练习，不过这一次使用for yield进行
        3.  给定一个整数数组，产出一个新的数组，包含原数组中的所有正值，以原有顺序排列，之后的元素是所有零或者负值，以原有顺序进行排列。  
            1，2，-3，5，-4，7，8  
            1247 -3 -4 -8
        4.  计算ARRAY\[DOUBLE\]的平均值  
            1，2，6，7，8，54，34，88，98
        5.  编写一个映射，其中包含有你有想要的装备以及他的价格。  
            例如：（“无尽”->3800,"饮血“->3700,“春哥”->2800,"布鞋"->300）  
            写一个方法，对每件装备打5折
        6.  打印出所有Java系统属性的表格，类似这样：  
            ![20190419220342444.png][]
        7.  编写一个函数minmax(values:Array\[Int\])，返回数组中最小值和最大值的对偶。
    10. 答案：
        
        1.  练习1
            
                
                object Test{
                  def main(args: Array[String]): Unit = {
                    //ARRAY(1,2,3,4)经过置换编程ARRAY(2,1,4,3)
                    val arr=Array(1,2,3,4,5)
                    val arr2=conviser(arr)
                    arr2.foreach(x => println(x))
                  }
                  
                  def conviser(arr:Array[Int]):Array[Int]={
                    if(arr.length<2){
                      arr
                    }else{
                      var x=0
                      while(x<arr.length-1){
                        val value=arr(x)
                        arr(x)=arr(x+1)
                        arr(x+1)=value
                        x+=2
                      }
                      arr
                     }
                  }
                }
        2.  练习2：for yield
            
                object Test{
                  def main(args: Array[String]): Unit = {
                    val arr=Array(1,2,3,4,5)
                    val arr2=between(arr)
                    arr2.foreach(x => println(x))
                  }
                  
                  def between(arr:Array[Int]):Array[Int]={
                     var t = arr.toBuffer
                     val result = for(i <- 0 until arr.length) yield {
                       if(i == t.length-1 && i % 2 == 0) t(i)
                       else if(i % 2 == 0 && i < t.length-1) t(i+1)
                       else t(i-1)
                     }
                     result.toArray
                     }
                }
        3.  练习3
        4.  练习4
            
                object Test{
                  def main(args: Array[String]): Unit = {
                    val arr=Array(1,2,6,7,8,54,34,88,98)
                    val value:Double=(arr.map(x=>x).sum)/(arr.length)
                    println(value)
                    
                  }
                }
                
                //33.0

[Scala]: https://www.yiibai.com/scala/scala_file_io.html
[20190224192334380.png]: /images/20220317/aed7d738431941deaffe96d8c299c99e.png
[20190419220342444.png]: /images/20220317/b3bf34f3b9674ccc9b851a458bb81dce.png