Scala阶段总结

╰半橙微兮° 2022-12-10 11:25 147阅读 0赞

一、基础及环境配置  
Scala构建在JVM之上，与java兼容，互通  
面向对象编程，函数式编程，表达能力强，代码精简  
安装包（要求jdk环境）：https://www.scala-lang.org/download  
在idea中安装scala环境：在idea的setting搜索Plugins（插件的意思），在插件栏搜索scala安装即可  
如果在线无法安装的话，可以从idea的官网找到对应版本的scala插件，下载到本地，选择从本地安装即可  
tips：scala插件的版本需要和idea的版本一致  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NTY2Njcz_size_16_color_FFFFFF_t_70_pic_center]

二、概述  
每个值都是对象  
对象的数据类型和行为由类（Class）和特质trait（类似java的接口）  
可以使用特质实现混入式多继承  
2.1基础知识  
var 变量，val常量  
数据类型：Byte，Short，Int，Long，Float，Double，Char，String，Boolean  
数据类型的层次：  
Any：所有类型的超类（是顶级类型）  
AnyVal：表示值类型的超类  
AnyRef：表示引用类型的超类  
Unit：表示无值，类似java中的void，无返回值的意思  
Nothing：所有类型的子类，什么也没有  
Null：表示null或空引用  
2.2字符串操作  
s插值器：允许将变量引用，表达式直接插入字符中

val name="James"
    println(s"Hello,$name")
    //输出的结果为：Hello，James

2.3条件控制  
if条件 控制：

val x=10
    if(x>10){
        
        print("x大于10")
    }else if(x==10){
        
        print("x等于10")
    }else{
        print("x小于10")}

条件语句的返回值

val x=10
    val y={
        
       print("我是代码块")
       x+1
    }

此表达式的返回值为(x+1)即11，  
代码块\{。。。。\}也是一个表达式，返回值为最后一个表达式结果  
while循环与for循环

var num: Int = 0;
    while ( num < 100 ) {
        
        println( num );
        num = num + 1;
    }
    
    var num: Int = 0;
    do {
        
        println( num );
         num = num + 5;
    } while ( num < 200 }

val num:Int = 10;
    for ( i: Int <- 1 to num )
    {
             
        println( i * 100 );
    }
    
    for {
         i: Int <- 1 until 100 }
    {
        
        val y = 2*i;
        println( y );
    }

1 to 10表示创建一个区间rang（1,2,3,4,5,6,7,8,9,10）

循环的中断：需要导包，by 2表示步长为2，不写表示默认步长为1

import scala.util.control.Breaks._
    val num:Int = 10;
    for ( i: Int <- 1 to num by 2 ) {
        
        if(i>=5) break;
        println( i * 100 );
    }

for循环添加条件过滤：用if添加过滤条件，添加多个条件用分号隔开

val num:Int = 10;
    for ( i: Int <- 1 to num; if i%2==0;if i>5 )
    {
            
        println( i * 100 );
    }

三、scala的数组  
存储固定大小的元素  
数组索引从0开始  
数组和一百多种方法

scala的元组：  
可以包含不同类型的元素，最多支持22个元素，使用下划线访问元素，\_1表示第一个元素

四、函数及参数调用  
4.1函数定义

def 函数名([参数列表]):[返回值]{
        
        函数体
        return[表达式]
    }

参数传递过程：  
传值调用，传名调用  
传值调用时，参数只在调用时计算一次，后续重复使用计算的结果  
传名调用时，参数在调用时不会计算，只有真正用到参数时才会计算

//传值调用，
    def square(x: Int): Int = {
        
        println(x)    //3
        x * x             //计算3*3
    }
    square(1+2)   //调用该square方法时，先计算1+2，然后将结果传进去
    
    //传名调用
    def square(x: => Int): Int = {
        
        println(x)    //计算1+2
        x * x             //计算(1+2)*(1+2)
    }
    square(1+2)   //调用该square方法时，不计算，只有在使用值时才会进行计算

4.2函数的参数  
通常情况下，传入参数与函数定义的参数列表一一对应，命名参数允许使用任意顺序传入参数  
可以通过指定参数，不按顺序进行传递

def printName(first:String, last:String) = {
        
        println(first + " " + last)
    }
    //Prints "John Smith"
    printName("John","Smith")
    printName(first = "John",last = "Smith")
    printName(last = "Smith",first = "John")

scala函数允许指定参数默认值，从而允许在调用时不指明该参数  
不传入参数的话会调用默认值

def printName(first:String="John", last:String="Smith") = {
        
        println(first + " " + last)
    }
    //Prints "John Smith"
    printName()

4.3匿名函数  
指不含函数名称的函数  
匿名函数的定义方法：  
“=> "的左边为参数列表  
“=> "的右边为函数体

//定义一个匿名函数
    val trim=(x:String)=>{
        println(x.trim)}
    def main(args: Array[String]): Unit = {
        
    //调用这个函数
    trim(" s dfasdfasd ")
    }

函数嵌套：scala函数内可以定义函数，函数内的函数也称为局部函数或者内嵌函数  
4.4隐式参数  
方法可以具有隐式参数列表，由参数列表开头的implicit关键字标记  
implicit只能修改最尾部的参数列表，应用其全部参数  
scala可以自动传递正确类型的隐式值  
通常与柯里化函数结合使用  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NTY2Njcz_size_16_color_FFFFFF_t_70_pic_center 1]

4.5隐式函数  
隐式函数也称隐式转化，使用implicit修饰的函数  
应用：隐式转换：

implicit def doubleToInt(x:Double)=x.toInt
    val i:Int=3.5
    //会将3.5转化为Int类型的

类型增强

implicit def booleanToInt(x:Boolean)=if(x)1 else 0
    println(1+true)
    //结果为1+1，true通过隐式函数转为Int了

五、scala面向对象  
1. 类：  
通过class关键字定义  
通过new创建实例  
拥有成员方法和变量  
类的成员默认为public，也支持private和protected  
类中无法定义静态成员变量和方法  
类无需明确定义构造方法，通过构造参数列表声明为类的一部分  
2. 类有主构造器和辅助构造器

//主构造器执行类定义中的所有语句
    class Point(xc: Int, yc: Int) {
        
      var x: Int = xc  //成员变量
      var y: Int = yc
      //辅助构造器
      def this() ={
        
        this(0, 0)  //第一句必须调用其他构造器
      }
      //成员方法
      def move(dx: Int, dy: Int) ={
        
        x = x + dx
        y = y + dy
      }
    }

//类的实例化
    var p=new Point()
    p.x
    p.y
    p=new Point(12,11)
    p.x
    p.y
    p.move(1,2)

3.类的继承

scala使用extends关键字实现继承  
子类重写父类方法必须使用override关键字  
4.抽象类  
抽象类可能包含未实现的方法，即抽象方法  
抽象类无法实例化  
抽象类使用abstract关键字修饰  
5.单例对象

*  scala中的类无法定义静态成员（即静态方法和静态变量），即无static关键字。
 *  scala使用单例对象实现像java一样表达类的静态成员变量，方法，代码块
 *  使用object关键字声明，可包含变量，方法，与代码块
 *  单例对象中的成员变量，成员方法通过单例对象名直接调用
 *  单例对象第一次被访问时初始化，并执行全部代码块
 *  单例对象不能new，且无构造参数
 *  单例对象那个与同名类定义在同一文件中时形成绑定关系

6.伴生关系

*  单例对象与同名类在同一文件中时形成绑定关系
 *  同名类称为单例对象的伴生类
 *  单例对象称为同名类的伴生对象
 *  伴生类与伴生对象可互相访问各自私有成员
 *  伴生对象可为伴生类增加静态成员

7.特质

*  scala中没有接口的概念
 *  特质用于在类之间共享程序接口和字段，类似java接口
 *  特质是字段和方法的集合，可以提供字段和方法的实现
 *  类和单例对象都可以扩展特质（extends）
 *  特质不能被实例化，因此没有构造参数，类似java接口
 *  特质使用trait关键字定义
 *  实现特质中的方法用override

8.混入特质

*  当某个特质被用于组合类时，称为混入
 *  一个类只能有一个父类，但是可以有多个父类（分别使用关键字extends和with）

abstract class A {
        
      val message: String
    }
    class B extends A {
        
      val message = "I'm an instance of class B"
    }
    trait C extends A {
        
      def loudMessage = message.toUpperCase()
    }
    //构造顺序由左往右，如果前面已经构造了某个父类，后面子类的该父类不会重复构造
    class D extends B with C
    val d = new D
    println(d.message)  // I'm an instance of class B
    println(d.loudMessage)  // I'M AN INSTANCE OF CLASS B

8.动态混入特质

class Drawing {
        
      //this:Type=> 自身类型，表示该类实例化时必须混入相应特质或子特质，self是this的别名。
      self: Shape =>
      def start(): Unit = draw()
    }
    trait Shape {
        
      def draw(): Unit
    }
    trait Square extends Shape {
        
      def draw(): Unit = println("draw a square")
    }
    trait Triangle extends Shape {
        
      def draw(): Unit = println("draw a triangle")
    }
    //动态混入
    (new Drawing() with Square).start()
    (new Drawing() with Triangle).start()

9.样例类  
样例类常用于描述不可变的值对象

case class Student(name:String,age:Int)      //定义样例类
    val stu=Student("Jason",19)      //创建样例类的实例，无需new关键字
    println(stu.name)       //访问对象属性

样例类构造参数默认声明为val，自动实现类构造参数的get特然  
当样例类的构造参数声明为var时，自动实现类构造参数的setter和getter  
样例类自动穿件伴生对象  
样例类自动实现的其他方法：toString()、equals()、copy()、hashCode()，\* 伴生对象中的apply()、unapply()

样例类和普通类的区别：

*  样例类通常用于描述不可变的数据，数据完全依赖构造参数
 *  样例类默认不可变，通过模式匹配可将其分解
 *  两个样例类“==”操作时，通过按值比较而不是按引用比较
 *  样例类操作更简单
 *  如果一个对象在内部执行有状态计算，或者表现出其他类型的复杂行为，那么他应该是一个普通类
    
    10.类型边界  
    在scala中，类型参数可以有一个类型边界约束  
    类型上界：将类型限制为另一种类型的子类  
    T<:A表示类型变量T应该是类型A的子类  
    A是具体类型，T是泛型  
    11.型变  
    协变  
    对于两种类型 A 和 B，如果 A 是 B 的子类型，那么 Foo\[A\] 就是 Foo\[B\] 的子类型

class Foo[+T]  // 协变类

逆变  
对于两种类型 A 和 B，如果 A 是 B 的子类型，那么 Bar\[B\] 就是 Bar\[A\] 的子类型

class Bar[-T]  // 逆变类

不变  
默认情况下，Scala中泛型类是不变的

class Baz[T]  // 不变类

六、scala模式匹配和正则  
match表达式（类似java的switch case语句）  
能够处理所有的类型，不需要break，能够生成值

val firstArg=if(args.length>0) args(0) else ""
    firstArg match{
        
        case "salt" => println("pepper")
        case "chips" => println("salsa")
        case "eggs" => println("bacon")
        case _ => println("huh?")  //以上未列出的值，使用“_”表示
    }

模式匹配：检查某个值是否匹配一个模式的机制，一个成功的匹配同时会将匹配值结构为其组成部分

//基本模式匹配
    def matchTest(x: Int): String = x match {
        
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
    }
    matchTest(3)  // many
    matchTest(1)  // one

//模式守卫（在模式后面加上if 条件）
    def matchTest2(x: Int): String = x match {
        
      case i if i==1 => "one"
      case i if i==2 => "two"
      case _ => "many"
    }
    matchTest2(3)  // many
    matchTest2(1)  // one

//仅匹配类型
    def matchTest3(x: Any): String = x match {
        
      case x:Int => "Int"
      case x:String => "String"
      case _ => "Any"
    }
    matchTest3(3.0)  // Any
    matchTest3(1)     // Int

//样例类的模式匹配
    def matchTest4(x: Student)= x match {
        
      case Student(name,19) => println(name)
      case Student("Tom",age) => println(age)
      case Student(name,age) => println(name,age)
      case _ => println("no matches")
    }
    matchTest4(Student("Jason",19))
    matchTest4(Student("Tom",20))
    matchTest4(Student("Jimmy",20))

正则表达式  
scala支持多种正则表达式解析方式  
“xxxx”.matches()方法  
正则表达式模式匹配

"!123".matches("[a-zA-Z0-9]{4}")  //false
    "34Az".matches("[a-zA-Z0-9]{4}")  //true

//模式匹配，Regex实现了提取器
    val ZipcodePattern = "([a-zA-Z][0-9][a-zA-Z] [0-9][a-zA-Z][0-9])".r
    "L3R 6M2" match {
        
        case ZipcodePattern(zc) => println("Valid zip-code: " + zc )  //zc为第1个分组结果，可以匹配多个分组
        case zc => println("Invalid zip-code: " + zc )
    }

*  findFirstMatchIn()返回第一个匹配的结果
 *  findAllMatchIn()返回所有匹配的结果
 *  findAllIn()返回所有匹配结果（String）
 *  replaceFirstIn替换第一个匹配的结果
 *  replaceAllIn替换所有匹配的结果

import scala.util.matching.Regex
    val numberPattern: Regex = "[0-9]".r
    numberPattern.findFirstMatchIn("awesomepassword") match {
        
      case Some(_) => println("Password OK")  //匹配成功
      case None => println("Password must contain a number")   //未匹配
    }

*  在字符串中查找模式

val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
    "2014-05-23" match {
        
        case date(year, month, day) => println(year,month,day)
    }
    "2014-05-23" match {
        
        case date(year, _*) => println("The year of the date is " + year)
    }
    "2014-05-23" match {
        
        case date(_*) => println("It is a date")
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NTY2Njcz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/c4f9cd41cd5a40d29b7629eb1476bbd3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NTY2Njcz_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/50fe9de2783f410d8bd4f602b12351c3.png