Scala教程

最新推荐文章于 2022-04-01 11:35:00 发布

yigg

最新推荐文章于 2022-04-01 11:35:00 发布

阅读量598

点赞数

分类专栏： # scala

本文链接：https://blog.csdn.net/yiguang_820/article/details/87905853

版权

scala 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

目录：

入门：Scala教程
进阶：Java集合与scala集合互操作
高阶函数

内容：

入门
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
面向对象和概念
1. Scala类和对象
2. Scala单例和伴生对象
3. Scala Case类和对象
4. Scala构造函数
5. Scala方法重载
6. Scala this关键字
7. Scala方法覆盖
8. Scala final关键字

进阶：Java集合与scala集合互操作：参考scala.collection.JavaConversions中有哪些集合可以进行互操作

scala.collection.Iterable <=> java.lang.Iterable
scala.collection.Iterable <=> java.util.Collection
scala.collection.Iterator <=> java.util.{ Iterator, Enumeration }

scala.collection.mutable.Buffer <=> java.util.List

//比如把Java的list快速转为scala的buffer
val scalaList = JavaConversions.asScalaBuffer(javaList)

scala.collection.mutable.Set <=> java.util.Set
scala.collection.mutable.Map <=> java.util.{ Map, Dictionary }
scala.collection.mutable.ConcurrentMap <=> java.util.concurrent.ConcurrentMap
scala.collection.Seq => java.util.List
scala.collection.mutable.Seq => java.util.List
scala.collection.Set => java.util.Set
scala.collection.Map => java.util.Map
java.util.Properties => scala.collection.mutable.Map[String, String]

示例：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

高级

Scala高阶函数

第一级别：作为变量的函数
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
```
第二级别：匿名函数
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
```

第三级别：带函数参数的函数

Scala中可以将某个函数传入其它函数，作为参数，这个功能是极其强大的
接收其他函数作为参数的函数，也被称作：高级函数（higher-order function）

示例：

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("你好")
  }
}

//打印结果为：高阶函数传过来的值为:你好

第四级别：返回一个函数的函数

高阶函数的另一个功能是将函数作为返回值

示例：

object Test{
  def main(args: Array[String]): Unit = {
    //创建一个匿名函数，赋值给变量
    var v1=hello("旧值")
    v1("新值")
  }
  
  /*
   * 将函数作为一个返回值
   */
  def hello(name:String)={
    (str:String)=>println("hello方法的值为："+name+"，返回再次调用的值为:"+str)
  }
}

//打印结果为:hello方法的值为：旧值，返回再次调用的值为:新值

柯里化函数
偏函数
递归函数
嵌套函数
尾递归

常用高阶函数

foreach也是高阶函数：

object Test{
  def main(args: Array[String]): Unit = {
    List(3,4,5,6).foreach(x=>println(x))
  }
}

/*打印结果为：
3
4
5
6
*/

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)

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的区别

filter高阶函数的使用

object Test{
  def main(args: Array[String]): Unit = {
    Array(1,2,3,4,5,6).filter(x=>x>4).foreach(println)
  }
}

打印结果为：
5
6

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

练习

（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

练习
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系统属性的表格，类似这样：
7. 编写一个函数minmax(values:Array[Int])，返回数组中最小值和最大值的对偶。

答案：

练习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：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

练习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