Scala学习之Scala入门基础知识篇

桃扇骨 2023-07-09 12:24 124阅读 0赞

## 二： Scala 入门 ##

### 2.1 var与val ###

> scala有两种变量类型为 var与val。一般val使用的更多。而他们在使用时必须先初始化，才能使用，否则报错，与java不同

//例：
    var a = 10
    val b = 10
    //也可以带上数据类型
    val b:Int = 10 //  <=> val b = 10
    //但是如果只创建且不初始化，会报错
    val a  //这样是不对的
    var b : Int // 这样也不对

直接来看，二者之间用法相同，不同点在于val定义后的变量不能改变，类似于被 final 所修饰的变量。

var 修饰的对象引用可以改变，val 修饰的则不可改变，但对象的状态却是可以改变的。（即对象不可改变，但对象里的数据域的值可以改变除非对象中的变量也是val）

*  多变量声明

val a,b = 10
    //  a = b =10

> 拓展：lazy 在修饰变量（修饰val）时，属于延迟加载，只有变量被调用时才会进行初始化。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xfamRfZ3VsdWx1_size_16_color_FFFFFF_t_70]

### 2.2 基本数据类型 ###

> **分为值类型AnyVal**和**引用类型AnyRef**

值类型包括：Byte，Short， Int，Long，Double，Float，Unit（类似于void），Boolean，Char

引用类型包括：String，List，Option，YourClass

他们都属于Any类，Nothing类型时他们的子类型

在类型上跟Java基本类似。

**注意：这些类型与Java不同点在于首字符大写**

//整型
    val a : Byte = 1
    val b : Short = 1
    val c : Int = 1
    val d : Long = 1 // 等价于 val d = 1L
    //浮点型
    val a = 1.0 //默认为Double类型
    val b =1.0F //Float类型
    //布尔类型
    val a = true //Boolean 类型
    val b : Boolean = false 
    //字符型
    val a = 'a'   //Char类型
    val c ='\u0062' //Unicode编码
    //String类型不同点：多行字符串
    val str = """
              Hello,
              World !         
              """
     //打印效果与字符串完全相同。

在使用输出时，几种常用方法

print()//一行输出不换行
    printf()//格式化输出，与C语言输出一致
    println()//换行输出
    //输出字符串时，我们java中要连续的使用+号来连接。
    //例：print("a * b = "+a*b);
    //s的常用用法： print(s"a * b =${a*b}")
    //使用一个$符号进行引用，更加方便，如果$后是一个，不用带大括号。

//其他类型：null
    //值类型不能为null
    //但引用类型可以为null
    val a :String = null

### 2.3 类型转换 ###

Scala类型转换有两种转换方式

*  对于值类型来说，小精度转换大精度能够进行自动转换，与java类似
 *  强制转换，大精度转换小精度可能会造成数据的溢出或者精度降低

一般常用方法如下:

val a = 10  //Int
    a.toDouble // 为Double类型。
    a.asInstanceOf[Double] //同样为Double类型

> 第一种方式为：调用 to+类型名,这种方法，注意：结尾不带（）

> 第二种方式为：调用 asInstanceOf\[T\] 方法，这种方法不仅使用值类型，也是用于引用类型，T指一种对象类型，与之相联系的有个 isInstanceOf\[T\] 方法，两者通常搭配使用，进行判断传进来的对象是否是所需要的对象，如果不是，根据多态的继承特性，将父类转换为子类使用。

### 2.4 标识符 ###

Scala标识符用法和Java基本类似，但略有不同。

开头不允许使用数字。

开头允许使用大小写字母，下划线，和美元符号（不推荐）后接任意字母和数字包括下划线

不同点：Scala里允许对运算符进行定义。

//例如
    val == =10
    val ++ =1.0F
    val + ='a'
    //这在Scala里面允许使用
    //注意点：=不允许被使用
    val = =10  //这样不规范，会报错

**注意：禁止连续多次使用空行**

> 因为Scala是面向行的一种语言，换行符和；都能结束语句。

### 2.5 运算符 ###

2.5.1 算术运算符

算术运算符包括 +，-，*，/，%
    
    同时每一个运算符也都是一个对象

//简单使用
    val a = 10 
    val b = 8
    var c = 0
    c = a.+(b)   //  c为18  相当于 a+b
    c = b.*(a)   //  c为80  相当于  b*a
    c = a - b    //  c为 2  即 a.-(b)

2.5.2 赋值运算符

赋值运算符包括：= （右->左） += -= \*= /= %= &= >>= ^= (先操作在赋值)等等

**注意：Scala不支持三目运算符，也不支持++，--这些自增自减的运算符**

2.5.2 关系运算符

关系运算符包括：>（大于） <（小于） == （等于） !=（不等于） >=（不小于） <=（不大于） 与其他高级语言类似

正确为true，否则为false

2.5.3 逻辑运算符

逻辑运算符包括：&&（与）||（或） ！（非）

&&：两边都正确为true，否则为false
    
    ||：两边都错误为false，否则为true
    
    ！：本身错误时true，否则false

2.5.4 位运算符（转换成二进制计算）

位运算包括：&(按位取与)    |（按位取或）    ~（取反,也叫“补”）   
    					^（按位异或）    >>（右移）    <<(左移)
    
    
    &：都为1才为1，否则为0
    
    简单应用：判断奇偶性

if(n & 1 == 0) //判断是否为偶数
    //即拿n的最后以为跟1进行与运算，如果为1说明最后一位为1，即为奇数，反之为偶数

|：都为0才为0，否则为1
    
    ~：0变1    1变0 （先转补码，在取反，在取补码）
    
    ^：相同为0，不同为1
    
    简单应用：两个数交换(不借助第三个变量)

val a = 10
    val b = 8
    a = a ^ b
    b = a ^ b
    a = a ^ b
    // 此时 a=8，b=10

>>：左侧补零

简单应用：>> 1

val a = 10
    val b = a >> 1
    //此时 b = a/2 = 5  作为除2运算

<< ：右侧补零

简单应用：<< 1

val a = 10
    val b = a << 1
    //此时 b = a*2 = 20  作为乘2运算

### 2.6 控制语句 ###

循环控制语句与Java类似，包括用法。

> 在Scala中没有Switch语句，而是通过模式匹配，match进行代替。（用法在方法函数里总结）

*  if-else if -else 语句

与Java类似

if（布尔表达式）\{\}

else if（布尔表达式）\{\}

…………

else\{\}

> 中间可不用 else if

布尔表达式为真，则执行相对应的代码块

*  有返回值的分支

val bool = if(true){
        
        代码块
        返回值
    }
    // 则bool值就是大括号里面的返回值。
    //  返回值类型一般是字符串或者是Unit，他们的父类是Any，AnyVal

### 2.7 循环语句 ###

循环语句有三种，与Java中的一样，分别是for，while，do—while语句。

> Scala中不存在break，continue 关键字。

*  for循环（重点，与Java不同）

1.  循环表达式 ——Range用法（左闭右开)

//第一种用法
    for(x <- Range(1,10)){
        
        print(x+" ")
    }
    //输出结果为    1 2 3 4 5 6 7 8 9 
    //即 从1到9，不包括10
    //第二种用法
    for(x <- Range(1,10,2)){
        
        print(x+" ")
    }
    //输出结果为    1 3 5 7 9 
    //所以第三个参数的意义是每隔n-1个,即下个数-上个数=n

1.  循环表达式 ——to用法（左闭右闭)

//第一种用法
    for(x <- 1 to 10){
        
        print(x+" ")
    } 
    //输出结果为    1 2 3 4 5 6 7 8 9 10 
    //即左右都是闭区间
    //第二种用法
    for(x <- 1.to(10)){
        
        print(x+" ")
    }
    //输出结果与第一种一样，体现出Scala中”万物“皆对象

循环表达式 ——until用法

> 用法与to类似，但效果与Range一样，都是左闭右开。

1.  for循环+if语句判断用法（循环守卫/循环控制）

for(x <- 1 to 10 if x % 2 == 0){
        
        print(x+" ")
    }
    // 结果为    2 4 6 8 10 
    //所以在for循环中也可以使用if语句，但后面不带括号

1.  遍历数组

val arr = Array(1,2,3,4,5)
    //第一种方法
    for(x <- 0 to arr.length-1){
         //或者为  0 until arr.length 或  Range(0,arr.length)
        print(arr(x)+" ")
    }
    //第二种方法
    for(x <- arr){
         //类似于Java中的增强版循环:foreach
        print(x+" ")
    }
    //第三种方法,最简单
    arr.foreach(x => print(x+" ")) //这是scala中的foreach
    //   => 的含义是，将左边的值作用于右边的函数，函数的返回值作为结果

1.  多参数for循环

for{
        i <- Range(1,10)
        j = i*2
        k = i+1
        if(i%2==0)}{
        
            print(s"$i:$j:$k")
        }
    /**运行结果
    2:4:3
    4:8:5
    6:12:7
    8:16:9
    需要将for()的小括号变成大括号然后一行一个赋值表达
    */

1.  for循环的返回值

val res = for(i<-1.to(10)){
        }
    //  返回值为(),即Unit类型
    
    val res1 = for(i<-1.to(10)) yield i
    println(res1)
    /**
    结果为 Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    自动转换为Vector类型。
    */
    
    val res2 = for(i <- "hello"){
        
        print(i+" ")
    }
    /**
    h e l l o
    会将字符串变成字符型数组进行遍历
    */

1.  循环终止，跳出循环

// 导包:import scala.util.control.Breaks
    for(i<- 1 to 10){
        
        if(i>5){
        
            Breaks.break()
        }
        print(i+" ")
    }
    print("结束")
    /**
    1 2 3 4 5 
    Exception in thread "main" scala.util.control.BreakControl
    循环直接停止，并且抛出异常，
    这也导致了程序终止，循环之后的代码执行不了。
    */

解决办法

Breaks.breakable(for(i<- 1 to 10){
        
        if(i>5){
        
            Breaks.break()
        }
        print(i+" ")
    })
    print("结束")
    /**
    1 2 3 4 5 结束
    成功跳出循环，并且程序接着运行。
    */
    //第二种解决方法
    import scala.util.control.Breaks._
    breakable(for(i<- 1 to 10){
        
        if(i>5){
        
            break()
        }
        print(i+" ")
    })
    print("结束")
    // 效果与第一种方法一样，更加简单

while循环与do-while与其他语言无差别，并且在scala中不常用这两种循环，为了防止变量的污染（因为这两个循环会用var进行定义变量，而后期我们很少会用var进行定义。）

*  while循环

与Java类似

while(布尔表达式)\{

代码块

*  do-while循环

与Java类似

do\{

代码块

\}while(布尔表达式)；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xfamRfZ3VsdWx1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200228204257921.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xfamRfZ3VsdWx1,size_16,color_FFFFFF,t_70