Scala系列——Scala入门篇

逃离我推掉我的手 2022-05-17 11:26 343阅读 0赞

# 一、基本语法 #

## 1、声明变量 ##

object VariableDemo {
      def main(args: Array[String]) {
        //使用val定义的变量值是不可变的，相当于java里用final修饰的变量
        val i = 1
        //使用var定义的变量是可变得，在Scala中鼓励使用val
        var s = "hello"
        //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
        //变量名在前，类型在后
        //Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型
        val str: String = "hello scala"
      }
    }

## 2、条件表达式 ##

Scala的的条件表达式比较简洁，例如：

object ConditionDemo {
 def main(args: Array[String]) {
 val x = 1
 //判断x的值，将结果赋给y
 val y = if (x > 0) 1 else -1
 //打印y的值
 println(y)
 
 //支持混合类型表达式
 val z = if (x > 1) 1 else "error"
 //打印z的值
 println(z)
 
 //如果缺失else，相当于if (x > 2) 1 else ()
 val m = if (x > 2) 1
 println(m)
 
 //在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
 val n = if (x > 2) 1 else ()
 println(n)
 
 //if和else if
 val k = if (x>90) "优秀" else if (x<90 && x>60) "及格" else "不及格"
 println(k)
 }
 }

## 3、块表达式 ##

object BlockExpressionDemo {
 def main(args: Array[String]) {
 val x = 0
 //在scala中{}中课包含一系列表达式，块中最后一个表达式的值就是块的值
 //下面就是一个块表达式
 val result = {
 if (x < 0){
 -1
 } else if(x >= 1) {
 1
 } else {
 "error"
 }
 }
 //result的值就是块表达式的结果
 println(result)
 }
 }

## 4、循环 ##

在scala中有for循环和while循环，用for循环比较多，for循环语法结构：for (i <- 表达式/数组/集合)

object ForDemo {
 def main(args: Array[String]) {
 //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
 //每次循环将区间中的一个值赋给i
 for (i <- 1 to 10)
 println(i)
 
 //for(i <- 数组)
 val arr = Array("a", "b", "c")
 for (i <- arr)
 println(i)
 
 //高级for循环
 //每个生成器都可以带一个条件，注意：if前面没有分号
 for(i <- 1 to 3; j <- 1 to 3 if i != j)
 print((10 * i + j) + " ")
 println()
 
 //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
 //每次迭代生成集合中的一个值
 val v = for (i <- 1 to 10) yield i * 10
 println(v)
 
 }
 
 }

## 5、运算符 ##

Scala中的+ - \* / %等操作符的作用与Java一样，位操作符 & | ^ >> <<也一样。只是有一点特别的：这些操作符实际上是方法。例如：

a + b

是如下方法调用的简写：

a.+(b)

a 方法 b可以写成 a.方法(b)

# 二、定义方法和函数 #

## 1、定义方法 ##

方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返回类型

![70][]

## 2、定义函数 ##

![70 1][]

## 3、方法和函数的区别 ##

在函数式编程语言中，它可以像任何其他数据类型一样被传递和操作，函数就是一个实例，这是和方法的区别。案例：首先定义一个方法，再定义一个函数，然后将函数传递到方法里面。

![70 2][]

object MethodAndFunctionDemo {
      //定义一个方法
      //方法m2参数要求是一个函数，函数的参数必须是两个Int类型
      //返回值类型也是Int类型
      def m1(f: (Int, Int) => Int) : Int = {
        f(2, 6)
      }
    
      //定义一个函数f1，参数是两个Int类型，返回值是一个Int类型
      val f1 = (x: Int, y: Int) => x + y
      //再定义一个函数f2
      val f2 = (m: Int, n: Int) => m * n
      //再定义一个函数f3,这个这里没用
      val f3:(Int,Double) =>(Double,Int)={
          (a,b)=>(b,a)
      }
    
      //main方法
      def main(args: Array[String]) {
    
        //调用m1方法，并传入f1函数
        val r1 = m1(f1)
        println(r1)
    
        //调用m1方法，并传入f2函数
        val r2 = m1(f2)
        println(r2)
      }
    }

## 4、将方法转换成函数 ##

![70 3][]

# 三、数组、映射、元组、集合 #

## 1、数组 ##

### 1.定长数组和变长数组 ###

object ArrayDemo {
      def main(args: Array[String]) {
    
        //初始化一个长度为8的定长数组，其所有元素均为0
        val arr1 = new Array[Int](8)
        arr1(0)=56
        arr1(4)=23
        //直接打印定长数组，内容为数组的hashcode值
        println(arr1)
        //将数组转换成数组缓冲，就可以看到原数组中的内容了
        //toBuffer会将数组转换长数组缓冲
        println(arr1.toBuffer)
    
        //注意：如果new，相当于调用了数组的apply方法，直接为数组赋值
        //初始化一个长度为1的定长数组
        val arr2 = Array[Int](10)
        println(arr2.toBuffer)
    
        //定义一个长度为3的定长数组
        val arr3 = Array("It", "is", "spark")
        //使用()来访问元素
        println(arr3(2))
        //
        //变长数组（数组缓冲）
        //如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
        val ab = ArrayBuffer[Int]()
        //向数组缓冲的尾部追加一个元素
        //+=尾部追加元素
        ab += 1
        //追加多个元素
        ab += (2, 3, 4, 5)
        //追加一个数组++=
        ab ++= Array(6, 7)
        //追加一个数组缓冲
        ab ++= ArrayBuffer(8,9)
        //打印数组缓冲ab
    
        //在数组某个位置插入元素用insert
        ab.insert(0, -1, 0)//在0的位置依次插入-1，0
        //删除数组某个位置的元素用remove
        ab.remove(8, 2)//在8的位置向后删除两个
        println(ab)
      }
    }

### 2.遍历数组 ###

![70 4][]

object ForArrayDemo {
 
 def main(args: Array[String]) {
 //初始化一个数组
 val arr = Array(1,2,3,4,5,6,7,8)
 //增强for循环
 for(i <- arr)
 println(i)
 
 //until会生成一个Range
 //reverse是将前面生成的Range反转
 for(i <- (0 until arr.length).reverse)
 println(arr(i))
 }
 }

### 3.数组转换 ###

yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

![70 5][]

object ArrayYieldDemo {
 def main(args: Array[String]) {
 //定义一个数组
 val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
 //将偶数取出乘以10后再生成一个新的数组
 val res = for (e <- arr if e % 2 == 0) yield e * 10
 println(res.toBuffer)
 
 //更高级的写法
 //filter是过滤，接收一个返回值为boolean的函数
 //map相当于将数组中的每一个元素取出来，应用传进去的函数
 val r = arr.filter(_ % 2 == 0).map(_ * 10)
 println(r.toBuffer)
 
 }
 }

说明：map和flatMap的区别，flatMap会先map然后再将数据压平。

![70 6][]

我们下面以统计单词个数为例：

![70 7][]

或者：

![70 8][]

### 4.数组常用算法 ###

在Scala中，数组上的某些方法对数组进行相应的操作非常方便！

![70 9][]

## 2、映射 ##

在Scala中，把哈希表这种数据结构叫做映射

### 1.构建映射 ###

![70 10][]

### 2.获取和修改映射中的值 ###

![70 11][]

我们也可以使用getOrElse来给其赋初始值，下面suke的值即为0了

![70 12][]

注意：在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变。例子：

![70 13][]

注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型

## 3、元组 ##

映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。

### 1.创建元组 ###

![70 14][]

### 2.获取元组中的值 ###

![70 15][]

### 3.将对偶的集合转换成映射 ###

![70 16][]

### 4.拉链操作 ###

zip命令可以将多个值绑定在一起

![70 17][]

注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数

## 4、集合 ##

在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）。Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质

### 1.序列 ###

不可变的序列 import scala.collection.immutable.\_ 。在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。

**9 :: List(5, 2)**    :: 操作符是将给定的头和尾创建一个新的列表

注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

object ImmutListDemo {
    
      def main(args: Array[String]) {
        //创建一个不可变的集合
        val lst1 = List(1,2,3)
        //将0插入到lst1的前面生成一个新的List
        val lst2 = 0 :: lst1
        val lst3 = lst1.::(0)
        val lst4 = 0 +: lst1
        val lst5 = lst1.+:(0)
    
        //将一个元素添加到lst1的后面产生一个新的集合
        val lst6 = lst1 :+ 3
    
        val lst0 = List(4,5,6)
        //将2个list合并成一个新的List
        val lst7 = lst1 ++ lst0
        //将lst1插入到lst0前面生成一个新的集合
        val lst8 = lst1 ++: lst0
    
        //将lst0插入到lst1前面生成一个新的集合
        val lst9 = lst1.:::(lst0)
    
        println(lst9)
      }
    }

可变的序列 import scala.collection.mutable.\_

object MutListDemo extends App{
      //构建一个可变列表，初始有3个元素1,2,3
      val lst0 = ListBuffer[Int](1,2,3)
      //创建一个空的可变列表
      val lst1 = new ListBuffer[Int]
      //向lst1中追加元素，注意：没有生成新的集合
      lst1 += 4
      lst1.append(5)
    
      //将lst1中的元素最近到lst0中， 注意：没有生成新的集合
      lst0 ++= lst1
    
      //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合，即lst0和lst1不变，++生成新的；+合并
      val lst2= lst0 ++ lst1
    
      //将元素追加到lst0的后面生成一个新的集合
      val lst3 = lst0 :+ 5
    }

### 2.Set ###

不可变的Set

import scala.collection.immutable.HashSet
    object MutListDemo extends App{
      //构建一个可变列表，初始有3个元素1,2,3
      val lst0 = ListBuffer[Int](1,2,3)
      //创建一个空的可变列表
      val lst1 = new ListBuffer[Int]
      //向lst1中追加元素，注意：没有生成新的集合
      lst1 += 4
      lst1.append(5)
    
      //将lst1中的元素最近到lst0中， 注意：没有生成新的集合
      lst0 ++= lst1
    
      //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合，即lst0和lst1不变，++生成新的；+合并
      val lst2= lst0 ++ lst1
    
      //将元素追加到lst0的后面生成一个新的集合
      val lst3 = lst0 :+ 5
    }

可变的Set

import scala.collection.mutable
    object MutSetDemo extends App{
      //创建一个可变的HashSet
      val set1 = new mutable.HashSet[Int]()
      //向HashSet中添加元素
      set1 += 2
      //add等价于+=
      set1.add(4)
      set1 ++= Set(1,3,5)
      println(set1)
      //删除一个元素
      set1 -= 5
      set1.remove(2)
      println(set1)
    }

### 3.Map ###

import scala.collection.mutable
    object MutMapDemo extends App{
      val map1 = new mutable.HashMap[String, Int]()
      //向map中添加数据
      map1("spark") = 1
      map1 += (("hadoop", 2))
      map1.put("storm", 3)
      println(map1)
    
      //从map中移除元素
      map1 -= "spark"
      map1.remove("hadoop")
      println(map1)
    }

# 四、类、对象、继承、特质 #

## 1、类 ##

### 1.类的定义 ###

//在Scala中，类并不用声明为public。
    //Scala源文件中可以包含多个类，所有这些类都具有公有可见性。
    class Person {
      //用val修饰的变量是只读属性，有getter但没有setter
      //（相当与Java中用final修饰的变量）
      val id = "9527"
    
      //用var修饰的变量既有getter又有setter
      var age: Int = 18
    
      //类私有字段,只能在类的内部和伴生对象使用
      private var name: String = "唐伯虎"
    
      //对象私有字段,访问权限更加严格的，Person类的方法只能访问到当前对象的字段
      private[this] val pet = "迪迦"
    }
    //这就是伴生对象
    object Person{
        def main(args: Array[String]) {
            var person=new Person
            person.name="涂山雅雅"
      }
            
    }

### 2.构造器 ###

注意：主构造器会执行类定义中的所有语句

/**
      *每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
      */
    class Student(val name: String, val age: Int){
      //主构造器会执行类定义中的所有语句
      println("执行主构造器")
    
      try {
        println("读取文件")
        Source.fromFile("D:/opt/AFIN/data.text").mkString
        throw new IOException("io exception")
      } catch {
        case e: NullPointerException => println("打印异常Exception : " + e)
        case e: IOException => println("打印异常Exception : " + e)
      } finally {
        println("执行finally部分")
      }
    
      private var gender = "male"
    
      //用this关键字定义辅助构造器
      def this(name: String, age: Int, gender: String){
        //每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
        this(name, age)//这里就是调用主构造器
        println("执行辅助构造器")
        this.gender = gender
      }
    }
    object Student{
      def main(args: Array[String]): Unit = {
        var student1=new Student("张三",27)//这里只执行主构造函数
        var student2=new Student("张三",27,"ss")//这里即执行主构造函数，又执行辅构造函数
      }
    }

私有构造器

/**
      *构造器参数可以不带val或var，如果不带val或var的参数至少被一个方法所使用，
      *那么它将会被提升为字段
      */
    //在类名后面加private就变成了私有的
    class Queen private(val name: String, prop: Array[String], private var age: Int = 18){
      
      println(prop.size)
    
      //prop被下面的方法使用后，prop就变成了不可变得对象私有字段，等同于private[this] val prop
      //如果没有被方法使用该参数将不被保存为字段，仅仅是一个可以被主构造器中的代码访问的普通参数
      def description = name + " is " + age + " years old with " + prop.toBuffer
    }
    
    object Queen{
      def main(args: Array[String]) {
        //私有的构造器，只有在其伴生对象中使用
        val q = new Queen("hat", Array("蜡烛", "飞娥"), 20)
        println(q.description())
      }
    }

## 2、对象 ##

### 1.单例对象 ###

在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的

*  存放工具方法和常量
 *  高效共享单个不可变的实例
 *  单例模式

object SingletonDemo {
      def main(args: Array[String]) {
        //单例对象，不需要new，用【类名.方法】调用对象中的方法
        val session = SessionFactory.getSession()
        println(session)
      }
    }
    
    object SessionFactory{
      //该部分相当于java中的静态块
      var counts = 5
      val sessions = new ArrayBuffer[Session]()
      while(counts > 0){
        sessions += new Session
        counts -= 1
      }
    
      //在object中的方法相当于java中的静态方法
      def getSession(): Session ={
        sessions.remove(0)
      }
    }
    
    class Session{
    
    }

### 2.伴生对象 ###

在Scala的类中，与类名相同的对象叫做伴生对象，类和伴生对象之间可以相互访问私有的方法和属性

class Dog {
      val id = 1
      private var name = "小狗"
    
      def printName(): Unit ={
        //在Dog类中可以访问伴生对象Dog的私有属性
        println(Dog.CONSTANT + name )
      }
    }
    
    /**
      * 伴生对象
      */
    object Dog {
    
      //伴生对象中的私有属性
      private val CONSTANT = "汪汪汪 : "
    
      def main(args: Array[String]) {
        val p = new Dog
        //访问私有的字段name
        p.name = "123"
        p.printName()
      }
    }

### 3.应用程序对象 ###

Scala程序都必须从一个对象的main方法开始，可以通过扩展App特质，不写main方法。

object AppObjectDemo extends App{
      //不用写main方法
      println("I love you Scala")
    }

## 3、继承 ##

### 1.扩展类 ###

在Scala中扩展类的方式和Java一样都是使用extends关键字

### 2.重写方法 ###

在Scala中重写一个非抽象的方法必须使用override修饰符

### 3.类型检查和转换 ###

<table style="width:0px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> Scala </td> 
 <td style="vertical-align:top;width:213.05pt;"> Java </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> obj.isInstanceOf[C] </td> 
 <td style="vertical-align:top;width:213.05pt;"> obj instanceof C </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> obj.asInstanceOf[C] </td> 
 <td style="vertical-align:top;width:213.05pt;"> (C)obj </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> classOf[C] </td> 
 <td style="vertical-align:top;width:213.05pt;"> C.class </td> 
 </tr> 
 </tbody> 
</table>

### 4.超类的构造 ###

object ClazzDemo {
      def main(args: Array[String]) {
        //val h = new Human
        //println(h.fight)
      }
    }
    //trait : 等同于java中的interface，且比java的接口要更强大。相当于java8的接口
    trait Flyable{
      def fly(): Unit ={
        println("I can fly")
      }
    
      def fight(): String
    }
    
    abstract class Animal {
      def run(): Int
      val name: String
    }
    
    class Human extends Animal with Flyable{
    
      val name = "abc"
    
      //打印几次"ABC"?
      val t1,t2,(a, b, c) = {
        println("ABC")
        (1,2,3)
      }
    
      println(a)
      println(t1._1)
    
      //在Scala中重写一个非抽象方法必须用override修饰
      override def fight(): String = {
        "棒子 老虎 鸡"
      }
      //在子类中重写超类的抽象方法时，不需要使用override关键字，写了也可以
      def run(): Int = {
        1
      }
    }

# 五、模式匹配和样例类 #

Scala有一个十分强大的模式匹配机制，可以应用到很多场合：如switch语句、类型检查等。并且Scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配。

## 1、匹配字符串 ##

object CaseDemo01 extends App{
      val arr = Array("飞天", "遁地", "下海")
      val name = arr(Random.nextInt(arr.length))
      name match {
        case "飞天" => println("飞天...")
        case "遁地" => println("遁地...")
        case _ => println("真不知道你们在说什么...")
      }
    }

## 2、匹配类型 ##

object CaseDemo01 extends App{
 //val v = if(x >= 5) 1 else if(x < 2) 2.0 else "hello"
 val arr = Array("hello", 1, 2.0, CaseDemo)
 val v = arr(Random.nextInt(4))
 println(v)
 v match {
 case x: Int => println("Int " + x)
 case y: Double if(y >= 0) => println("Double "+ y)
 case z: String => println("String " + z)
 case _ => throw new Exception("not match exception")
 }
 }

注意：case y: Double if(y >= 0) => ... ，模式匹配的时候还可以添加守卫条件。如不符合守卫条件，将掉入case \_中

## 3、匹配数组、元组 ##

object CaseDemo03 extends App{
    
      val arr = Array(1, 3, 5)
      arr match {
        case Array(1, x, y) => println(x + " " + y)
        case Array(0) => println("only 0")
        case Array(0, _*) => println("0 ...")
        case _ => println("something else")
      }
    
      val lst = List(3, -1)
      lst match {
        case 0 :: Nil => println("only 0")
        case x :: y :: Nil => println(s"x: $x y: $y")//和el表达式一样，前面加s，取值用$
        case 0 :: tail => println("0 ...")
        case _ => println("something else")
      }
    
      val tup = (2, 3, 7)
      tup match {
        case (1, x, y) => println(s"1, $x , $y")
        case (_, z, 5) => println(z)
        case _ => println("else")
      }
    }

注意：在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。

9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表。:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

## 4、样例类 ##

在Scala中样例类是一中特殊的类，可用于模式匹配。case class是多例的，后面要跟构造参数，case object是单例的

case class SubmitTask(id: String, name: String)
    case class HeartBeat(time: Long)
    case object CheckTimeOutTask
    
    object CaseDemo04 extends App{
      val arr = Array(CheckTimeOutTask, HeartBeat(12333), SubmitTask("0001", "task-0001"))
    
      arr(Random.nextInt(arr.length)) match {
        case SubmitTask(id, name) => {
          println(s"$id, $name")//前面需要加上s, $id直接取id的值
        }
        case HeartBeat(time) => {
          println(time)
        }
        case CheckTimeOutTask => {
          println("check")
        }
      }
    }

## 5、Option类型 ##

在Scala中Option类型样例类用来表示可能存在或也可能不存在的值(Option的子类有Some和None)。Some包装了某个值，None表示没有值

object OptionDemo {
      def main(args: Array[String]) {
        val map = Map("a" -> 1, "b" -> 2)
        val v = map.get("b") match {
          case Some(i) => i
          case None => 0
        }
        println(v)
        //更好的方式
        val v1 = map.getOrElse("c", 0)
        println(v1)
      }
    }

## 6、偏函数 ##

被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction\[A, B\]的一个实例，A代表参数类型，B代表返回类型，常用作输入模式匹配

object PartialFuncDemo {
    
      def func1: PartialFunction[String, Int] = {
        case "one" => 1
        case "two" => 2
        case _ => -1
      }
    
      def func2(num: String) : Int = num match {
        case "one" => 1
        case "two" => 2
        case _ => -1
      }
    
      def main(args: Array[String]) {
        println(func1("one"))
        println(func2("one"))
      }
    }

[70]: /images/20220517/ee726cfcbc524489a91f3f810f7c57f0.png
[70 1]: /images/20220517/c0a21fc429f34b97947bc4da860c810e.png
[70 2]: /images/20220517/7d06d5c089f7489b85bcc1baec63eca0.png
[70 3]: /images/20220517/a5820e58e0284cb6891cce6848dd3524.png
[70 4]: /images/20220517/8e37f239a63f437ebfd28383ab7af29b.png
[70 5]: /images/20220517/faa635a8ca1c499ca0bbd96686b014cb.png
[70 6]: /images/20220517/a8d0db79b1104d4d818c62bc856b7274.png
[70 7]: /images/20220517/ad093e3da19641f19af654bdd54599a1.png
[70 8]: /images/20220517/9c6b3274a7454fa7921704bba18ac1e8.png
[70 9]: /images/20220517/bd253a3d2363477799ccc4facb21b2d5.png
[70 10]: /images/20220517/0d4256e1ac3b45bab91d9c3336b5dd5a.png
[70 11]: /images/20220517/33dfe4edc40c49f1a0cca5437200a6c4.png
[70 12]: /images/20220517/d1b6372857624605a6d0db5604fe7d42.png
[70 13]: /images/20220517/f524c1e0241d48f887bde011045691ca.png
[70 14]: /images/20220517/ad950527da8f42adb0b48ffc1ef6cf4b.png
[70 15]: /images/20220517/aa5f8d755e1c4726aabffae34553d5ae.png
[70 16]: /images/20220517/10e18b7d9e2f40cf8449d10758b0f49e.png
[70 17]: /images/20220517/2cbe17a326f5443ebc9c6474442a3e5f.png