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

二： 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）时，属于延迟加载，只有变量被调用时才会进行初始化。

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 

2. 循环表达式 ——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一样，都是左闭右开。

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

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

4. 遍历数组

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
//   => 的含义是，将左边的值作用于右边的函数，函数的返回值作为结果

5. 多参数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()的小括号变成大括号然后一行一个赋值表达
*/

6. 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
会将字符串变成字符型数组进行遍历
*/

7. 循环终止，跳出循环

// 导包: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(布尔表达式)；