• 2023_Spark_实验四：SCALA基础

    一、在IDEA中执行以下语句

    或者用windows徽标+R  输入cmd 进入命令提示符

    输入scala直接进入编写界面

    1、Scala的常用数据类型

    注意：在Scala中，任何数据都是对象。例如：

    1. scala> 1
    2. res0: Int = 1
    3.  
    4. scala> 1.toString
    5. res1: String = 1
    6.  
    7. scala> "1".toInt
    8. res2: Int = 1
    9.  
    10. scala> "abc".toInt
    11. java.lang.NumberFormatException: For input string: "abc"
    12.   at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    13.   at java.lang.Integer.parseInt(Integer.java:580)
    14.   at java.lang.Integer.parseInt(Integer.java:615)
    15.   at scala.collection.immutable.StringLike$class.toInt(StringLike.scala:272)
    16.   at scala.collection.immutable.StringOps.toInt(StringOps.scala:29)
    17.   ... 32 elided

    1. 数值类型：Byte，Short，Int，Long，Float，Double

    Byte: 8位有符号数字，从-128 到 127

    Short: 16位有符号数据，从-32768 到 32767

    Int： 32位有符号数据

    Long： 64位有符号数据

    例如：

    val a:Byte = 10

    a+10

    得到：res9: Int = 

    这里的res9是新生成变量的名字

    val b:Short = 20

    a+b

    注意：在Scala中，定义变量可以不指定类型，因为Scala会进行类型的自动推导。

    2. 字符类型和字符串类型：Char和String

        对于字符串，在Scala中可以进行插值操作。

    1.  
    2. scala> val s1="Hello World"
    3.  
    4. s1: String = Hello World
    5.  
    6.  
    7.  
    8. scala> "My Name is ${s1}"
    9.  
    10. res4: String = My Name is ${s1}
    11.  
    12.  
    13.  
    14. scala> s"My Name is ${s1}"
    15.  
    16. res5: String = My Name is Hello World

    3. Unit类型：相当于Java中的void类型

    1.  
    2. scala> val f=()
    3.  
    4. f: Unit = ()
    5.  
    6.  
    7.  
    8. scala> val f={}
    9.  
    10. f: Unit = ()

    4. Nothing类型：一般表示在执行过程中，产生了Exception

    例如，我们定义一个函数如下：

    1.  
    2. scala> def myfunction=throw new Exception("Some Error")
    3.  
    4. myfunction: Nothing

    2、Scala变量的申明和使用

    使用val和var申明变量

    例如：scala> val answer = 8 * 3 + 2 可以在后续表达式中使用这些名称

    val：定义的值实际是一个常量

    要申明其值可变的变量：var

    注意：可以不用显式指定变量的类型，Scala会进行自动的类型推到

    3、Scala的函数和方法的使用

    可以使用Scala的预定义函数

    例如：求两个值的最大值

    1.  
    2. scala> max(1,2)
    3.  
    4. :12: error: not found: value max
    5.  
    6.        max(1,2)
    7.  
    8.        ^
    9.  
    10.  
    11.  
    12. scala> import scala.math._
    13.  
    14. import scala.math._
    15.  
    16.  
    17.  
    18. scala> max(1,2)
    19.  
    20. res7: Int = 2
    21.  
    22.  
    23.  
    24. scala> var result:Int=max(1,2)
    25.  
    26. result: Int = 2

    也可以使用def关键字自定义函数

    语法：

    1.  
    2. //求两个参数的和
    3.  
    4. def sum(x:Int,y:Int):Int=x+y
    5.  
    6. sum(1,2)
    7.  
    8. var d=sum(1,2)
    9.  
    10.  
    11.  
    12. //求每个数学的阶乘
    13.  
    14. def myFactor(x:Int):Int={
    15.  
    16. //采用递归算法得到阶乘
    17.  
    18. //注意：在SCALA 中，if..else 是一个表达式，所有有返回值，相当于省略的return
    19.  
    20.  
    21.  
    22. if (x<=1)
    23.  
    24. 1
    25.  
    26. else
    27.  
    28. x*myFactor(x-1)
    29.  
    30. }
    31.  
    32. myFactor(5)

    4、Scala的条件表达式

    Scala的if/else语法结构和Java或C++一样。

    不过，在Scala中，if/else是表达式，有值，这个值就是跟在if或else之后的表达式的值。

    5、Scala的循环

    Scala拥有与Java和C++相同的while和do循环

    Scala中，可以使用for和foreach进行迭代

    使用for循环案例：

    1.  
    2. //定义一个集合
    3.  
    4. var list=List("Mary","Tom","Mike")
    5.  
    6. println("************for 第一种写法************")
    7.  
    8. for (s<-list) println(s)
    9.  
    10.  
    11.  
    12. println("************for 第二种写法************")
    13.  
    14.  
    15.  
    16. for {
    17.  
    18. s<-list
    19.  
    20. if(s.length>3)
    21.  
    22. } println(s)
    23.  
    24. println("************for 第三种写法************")
    25.  
    26.  
    27.  
    28. for (s<-list if s.length<=3) println(s)

    注意：

    （*） <- 表示Scala中的generator，即：提取符

    （*）第三种写法是第二种写法的简写

    在for循环中，还可以使用yield关键字来产生一个新的集合

    1. //定义一个集合
    2.  
    3.  
    4.  
    5. var list=List("Mary","Tom","Mike")
    6.  
    7.  
    8.  
    9. println("************for 第四种写法************")
    10.  
    11. var newList= for {
    12.  
    13. s<-list
    14.  
    15. s1=s.toUpperCase
    16.  
    17. } yield (s1)

    使用while循环：注意使用小括号，不是中括号

    1.  
    2. println("************while 循环************")
    3.  
    4. var i=0
    5.  
    6. while(i
    7.  
    8. println(list(i))
    9.  
    10. i+=1
    11.  
    12. }

    使用do ... while循环

    1.  
    2. println("************do while 循环************")
    3.  
    4. var i=0
    5.  
    6. do {
    7.  
    8. println(list(i))
    9.  
    10. i+=1
    11.  
    12. }while (i

    使用foreach进行迭代

    1.  
    2. scala> val list=List("Mary","Tom","Mike")
    3.  
    4. list: List[String] = List(Mary, Tom, Mike)
    5.  
    6.  
    7.  
    8. scala> list.foreach(println)
    9.  
    10. Mary
    11.  
    12. Tom
    13.  
    14. Mike

    注意：在上面的例子中，foreach接收了另一个函数（println）作为值

    6、Scala函数的参数

    Scala中，有两种函数参数的求值策略

    Call By Value：对函数实参求值，且仅求一次

    Call By Name：函数实参每次在函数体内被用到时都会求值

    1. //Scala中函数参数的求值策略
    2.  
    3. // 1.call by value
    4. def test1(x:Int,y:Int):Int=x+x
    5.  
    6. test1(3+4,8)
    7.  
    8.  
    9.  
    10. //2. call by name
    11. def test2(x: => Int,y: =>Int):Int=x+x
    12.  
    13. test2(3+4,8)

    稍微复杂一点的例子：

    x是call by value，y是call by name

    def bar(x:Int,y: => Int):Int = 1

    定义一个死循环

    def loop():Int = loop

    调用：

    bar(1,loop) //输出1

    bar(loop,1) //死循环

    我们来分析一下，上面两个调用执行的过程：

    Scala中的函数参数

    默认参数

    代名参数

    可变参数

    1.  
    2. //默认参数
    3.  
    4.  
    5.  
    6. def func1(name:String="Tom"):String ="Hello "+name
    7.  
    8. func1()
    9.  
    10. func1("marry")
    11.  
    12.  
    13.  
    14. //带名参数
    15.  
    16. def func2(str:String="Good Morning",name:String="Tom",age:Int=20)=str+name+" and the age of "+name + " is "+age
    17.  
    18. func2()
    19.  
    20. func2(age=25)
    21.  
    22.  
    23.  
    24. //变长参数：求多个数字的和
    25.  
    26. def sum(args:Int*)={
    27.  
    28. var result=0
    29.  
    30. for(arg<-args) result+=arg
    31.  
    32. result
    33.  
    34. }

    7、Scala的Lazy值（懒值）

    当val被申明为lazy时，它的初始化将被推迟，直到我们首次对它取值。

    1.  
    2. val x:Int =10
    3.  
    4.  
    5.  
    6. //定义y的时候才有lazy来休息，在定义它时候不会对其运算
    7.  
    8. lazy val y:Int=x+1
    9.  
    10. //第一次使用的时候，才会对其求值
    11.  
    12. y

    一个更为复杂一点的例子：读取文件：

    1.  
    2. //第一次读取一个存在的文件
    3.  
    4. val words=scala.io.Source.fromFile("d:\\temp\\a.txt").mkString
    5.  
    6. lazy val words1=scala.io.Source.fromFile("d:\\temp\\a.txt").mkString
    7.  
    8. words1
    9.  
    10. //第二次读取一个不存在的文件，这时不会报错
    11.  
    12. lazy val words2=scala.io.Source.fromFile("d:\\temp\\abc.txt").mkString
    13.  
    14.  
    15.  
    16. //第一次调用的时候，才会对其运算，才会出现Exception
    17.  
    18. words2

    8、异常的处理

    Scala异常的工作机制和Java或者C++一样。直接使用throw关键字抛出异常。

    使用try...catch...finally来捕获和处理异常：

    1.  
    2. //1.采用 try catch finally 来捕获异常和处理异常
    3.  
    4.  
    5.  
    6. try{
    7.  
    8. val words=scala.io.Source.fromFile("d:\\temp\\abc.txt").mkString
    9.  
    10. } catch {
    11.  
    12. case ex:java.io.FileNotFoundException => {
    13.  
    14. println("File Not Found")
    15.  
    16. }
    17.  
    18. case ex:IllegalArgumentException => {
    19.  
    20. println("Illegal Argument Exception")
    21.  
    22. }
    23.  
    24. case _:Exception =>{
    25.  
    26. println("*****Other Exception ****")
    27.  
    28. }
    29.  
    30. }finally {
    31.  
    32. println("****** final block ******")
    33.  
    34. }
    35.  
    36.  
    37.  
    38. //2.如果一个函数的返回类型是Nothing, 表示：在函数执行的过程中产生异样
    39.  
    40.  
    41.  
    42. def func1()=throw new IllegalArgumentException("Some Error Happened")
    43.  
    44.  
    45.  
    46. //3.if else 语句：如果在一个分支中产生了异常，则另外一个分支的返回值，将作为 if else 返回值的类型
    47.  
    48. val x=10
    49.  
    50. if(x>10){
    51.  
    52. scala.math.sqrt(x)
    53.  
    54. }else{
    55.  
    56. throw new IllegalArgumentException("The value should be not")
    57.  
    58. }

    9、Scala中的数组

    Scala数组的类型：

    定长数组：使用关键字Array

    1.  
    2. //定长数组
    3.  
    4. val a=new Array[Int](10)
    5.  
    6. val b=new Array[String](5)
    7.  
    8. val c=Array("Tom","Mary","Mike")

    变长数组：使用关键字ArrayBuffer

    1. //变长数组： ArrayBuffer
    2.  
    3. val d = scala.collection.mutable.ArrayBuffer[Int] ()
    4.  
    5. //往变长数组中加入元素
    6.  
    7. d+=1
    8.  
    9. d+=2
    10.  
    11. d+=3
    12.  
    13. //往变长数组中加入多个元素
    14.  
    15. d+=(10,12,13)
    16.  
    17. //去掉最后两个值
    18.  
    19. d.trimEnd(2)
    20.  
    21. d.trimStart(2)
    22.  
    23. //将ArrayBuffer 转换成Array
    24.  
    25. d.toArray

    遍历数组

    1.  
    2. //遍历数组
    3.  
    4. var a=Array("Tom","Mary","Mike")
    5.  
    6.  
    7.  
    8. //使用for 循环进行遍历
    9.  
    10. for (s<-a) println(s)
    11.  
    12.  
    13.  
    14. //对数组进行转换，新生成一个数组 yield
    15.  
    16. val b = for {
    17.  
    18. s<-a
    19.  
    20. s1=s.toUpperCase
    21.  
    22. }yield (s1)
    23.  
    24.  
    25.  
    26. //可以使用foreach进行循环输出
    27.  
    28. a.foreach(println)
    29.  
    30. b.foreach(println)

    Scala数组的常用操作

    1.  
    2. import scala.collection.mutable.ArrayBuffer
    3.  
    4.  
    5.  
    6. val myArray = Array(1,10,2,3,5,4)
    7.  
    8. //求最大值
    9.  
    10. myArray.max
    11.  
    12.  
    13.  
    14. //求最小值
    15.  
    16. myArray.min
    17.  
    18.  
    19.  
    20. //求和
    21.  
    22. myArray.sum
    23.  
    24.  
    25.  
    26. //定义一个变长数组
    27.  
    28.  
    29.  
    30. var myArray1=ArrayBuffer(1,10,2,3,5,4)
    31.  
    32. //排序
    33.  
    34. myArray1.sortWith(_ > _)
    35.  
    36.  
    37.  
    38. //升序
    39.  
    40.  
    41.  
    42. myArray1.sortWith(_ < _)

    Scala的多维数组

    和Java一样，多维数组是通过数组的数组来实现的。

    也可以创建不规则的数组，每一行的长度各不相同。

    1.  
    2. //定义一个固定长度的二维数组
    3.  
    4. val matrix = Array.ofDim[Int](3,4)
    5.  
    6. matrix(1)(2)=10
    7.  
    8. matrix
    9.  
    10.  
    11.  
    12. //定义一个二维数组，其中每个元素是一个一维数组，其长度不固定
    13.  
    14.  
    15.  
    16. val triangle = new Array[Array[Int]](10)
    17.  
    18. //通过一个循环赋值
    19.  
    20. for(i<-0 until( triangle.length)) triangle(i)=new Array[Int](i+1)
    21.  
    22. //观察这个二维数组中的每一个元素的长度
    23.  
    24. triangle

    10、映射

    映射就是Map集合，由一个(key,value)组成。

    -> 操作符用来创建

    映射的类型分为：不可变Map和可变Map

    1.  
    2. //不可变得Map
    3.  
    4. val math = scala.collection.immutable.Map("Alice"->80,"Bob"->95,"Mary"->70)
    5.  
    6.  
    7.  
    8. //可变的Map
    9.  
    10. val english = scala.collection.mutable.Map("Alice"->80,"Bob"->95,"Mary"->70)
    11.  
    12. val chinese = scala.collection.mutable.Map(("Alice",80),("Bob",95),("Mary",70))

    映射的操作

    获取映射中的值

    1. //1.获取Map中的值
    2.  
    3. chinese("Bob") //chinese.get("Bob")
    4.  
    5. //chinese("Tom") 如果不存在，会抛出 Exception
    6.  
    7. //Map.constains 判断可以时候存在
    8.  
    9. if(chinese.contains("Alice")){
    10.  
    11. chinese("Alice")
    12.  
    13. }else{
    14.  
    15. -1
    16.  
    17. }
    18.  
    19.  
    20.  
    21. //简写
    22.  
    23.  
    24.  
    25. chinese.getOrElse("Alice",-1)

    迭代映射

    1.  
    2. //迭代映射
    3.  
    4. for (s<-chinese) println(s)
    5.  
    6. chinese.foreach(println)

    11、元组（Tuple）

    元组是不同类型的值的聚集。

    例如：val t = (1, 3.14, "Fred") // 类型为Tuple3[Int, Double, java.lang.String]

    这里：Tuple是类型，3是表示元组中有三个元素。

    元组的访问和遍历：

    1.  
    2. //定义tuple,包含3个元素
    3.  
    4. val t1=(1,2,"Tom")
    5.  
    6. val t2= new Tuple4("Mary",3.14,100,"Hello")
    7.  
    8.  
    9.  
    10. //访问tuple中的组员 _1
    11.  
    12. t2._1
    13.  
    14. t2._2
    15.  
    16. t2._3
    17.  
    18. t2._4
    19.  
    20.  
    21.  
    22. //t2._5 ---->error
    23.  
    24.  
    25.  
    26. //遍历 Tuple: for foreach ???
    27.  
    28.  
    29.  
    30. t2.productIterator.foreach(println)
    31.  
    32. //注意：要遍历Tuple中的元素，需要首先生成对应的迭代器，不能直接使用for 或者 foreach

  • 相关阅读:
    【Java基础】· 集合习题详解
    log4j2安全漏洞修复
    Spring的web集成 (Spring监听器)
    51单片机点阵
    ios ipa包上传需要什么工具
    Linux高性能服务器编程——ch4笔记
    大数据-之LibrA数据库系统告警处理（ALM-12046 网络写包丢包率超过阈值）
    电磁铁常见故障有哪些
    js-gerenator-async异步迭代器错误处理及+promise
    wires hark抓包内容解析
  • 原文地址：https://blog.csdn.net/pblh123/article/details/132623887