Scala从入门到精通

第一章

1. scala简介

scalable language，运行在jvm上，面向对象和面向函数式编程。

兼容java，可以访问庞大的java类库

2. scala与java对比

执行流程

3. scala环境搭建

IDEA插件下载地址：http:/.plugins.jetbrains.com/plugin/1347-scala

版本必需和IDEA保持一致

下载插件后，IDEA使用从本地安装插件

4. scala解释器

cmd -> scala

（1）hello world

第二章

2.1 输出语句和分号

1. 输出语句

  换行输出：println

  不换行输出：print

  输出多个值：println(value1, value2, value3...)

2. 分号

  可以写，也可以不写

2.2 常量

1. 分类

（1）字面常量：整型常量(如：2)，浮点型常量(如：1.2)，字符常量(如：'a')，字符串常量(如："abc")，布尔常量(如：true, false)，空常量(如：null)

（2）自定义常量

2.3 变量

1. 语法格式

val/var 变量名:变量类型 = 初始值

其中：

val定义的是不可重新赋值的变量，也就是自定义常量

var定义的是可以重新赋值的变量

2. 示例

定义一个变量保存一个人的名字“tom”

val name:String = "tom"

3. 类型推断

val name = "tom"

2.3 字符串

三种定义方式：

（1）使用双引号

（2）使用插值表达式

（3）使用三引号

1. 使用双引号

var name = "hadoop"
println(name + name.length) //hadoop6

2. 使用插值表达式

如果涉及大量字符串的拼接，使用插值表达式

val/var 变量名 = s"${变量/表达式}字符串"

示例：定义变量保存“zhagnsan”, 23, "male"，定义字符串打印输出：name=zhangsan, age=23, sex=male

val name = "zhangsan"
val age = 23
val sex = "male"
val info = s"name = ${name}, age = ${age}, sex = ${sex}"
println(info) //name = zhangsan, age = 23, sex = male

3. 使用三引号

如果涉及大段文本

val sql = """
     select *
     from stu
     where name = 'zhangsan'
     and age = 23
     order by addr;
     """
println(sql)

4. 惰性赋值

lazy val/var 变量名 = 表达式

2.4 标识符

1. 变量或方法名：小驼峰命名法

2. 类或特质：大驼峰命名法

3. 包：全部小写，多级目录使用"."隔开

2.5 数据类型

 1. 类型继承图

（1）Any：所有类型的父类，相当于java中的Object类

（2）AnyVal：所有数值类型的父类

（3）AnyRef：所有引用类型的父类

（4）Unit：相当于java中的void

（5）Null：所有引用类型的子类，它的值只有null

（6）Nothing：所有数据类型的子类，它一般结合异常来进行使用

 2. 判断是否有误

val b:Int = null //报错，Int是数值类型，null是引用类型

2.6 类型转换

1. 强制类型转换

val/var 变量名:数据类型 = 具体的值.toXXX
例如：
var age = 3.14.toInt //3

2. 值类型数据转成字符串类型数据

val/var 变量名:String = 值类型数据 + ""
val/var 变量名:String = 值类型数据.toString

3. String类型转换成值类型数据

（1）转成Char的方法是“.toCharArray”

2.7 键盘录入

1. 使用步骤

（1）导包：import scala.io.StdIn

（2）通过StdIn.readxxx()来接收用户录入的数据：StdIn.readLine(), StdIn.readInt ()

第三章

3.1 算术运算符

1. 字符串与整数使用乘法计算，相当于字符串拷贝n份

2. 取模运算：a % b = a - a / b * b (10 % 3 = 1, -10 % 3 = -1, 10 % -3 = 1)

3.2 赋值运算符

3.3 关系运算符

val s1 = "abc"
val s2 = "abc"
println(s1 == s2, s1.eq(s2))  //true, false

3.4 逻辑运算符

3.5 位运算符

原码，反码和补码

计算机底层存储，操作和运算数据都是采用数据的二进制补码形式实现

正数：原码，反码和补码都一样，不需要计算

负数：

   反码计算规则：原码的符号位不变，数值位按位取反

   补码计算规则：反码 + 1

第四章

4.1 流程控制结构

4.2 分支结构

1. scala没有三元表达式

2. scala条件表达式有返回值（java不行）

val sex = "male"
val result = if(sex == "male") 1 else 0
println(result)  //1

3. 块表达式

使用"{}"表示一个块表达式，它和条件表达式一样具有返回值，值为最后一个表达式

val a = {
       var b = "aaa"
       b + "11"
     }
print(a) //aaa11

4.3 循环结构

1. for循环

for(i <- 表达式/数组/集合) {
    //逻辑代码
}

var num = 1 to 10
for(i <- num) {
     println("num: " + i)
}
/**
num: 1
num: 2
num: 3
num: 4
num: 5
num: 6
num: 7
num: 8
num: 9
num: 10
*/

for(i <- 1 to 3; j <- 1 to 5) if(j == 5) println("*") else print("*")
/**
*****
*****
*****
*/

2. 守卫

for表达式中，可以添加if判断语句，这个if判断语句称为“守卫”，每一次遍历时都会经过if判断，如果为true，才会执行for大括号中的逻辑代码

for(i <- 表达式/数组/集合 if 表达式) {
    //逻辑代码
}

for(i <- 1 to 10 if i % 3 == 0){
    println(i)
}
//3 6 9

3. for推导式

在scala中，for循环是有返回值的，可以使用yield表达式构建处一个集合。使用yield的for表达式称为“推导式”。

val result = for(i <- 1 to 10) yield i *10
println(result) //(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

4. scala中没有break和continue

第五章

5.1 方法

1. 语法格式

def 方法名(参数名:参数类型, 参数名:参数类型) : [return type] = {方法体}

（1）参数列表的参数类型不能省略

（2）返回值类型可以省略

（3）返回值可以不写return，默认就是{}块表达式的值

2. 示例

获取两个数字中的最大值

def getMax(a:Int, b:Int):Int = if(a > b) a else b
println(getMax(3, 13)) //13

3. 返回值类型推断

如果定义的是递归方法，那么不能省略返回值类型

4. 惰性方法

当记录方法返回值的变量被声明为lazy时，方法的执行将被推迟，直到首次使用该值时，方法才会被执行，这种方法叫惰性方法。

java中没有提供惰性技术，但是可以通过懒加载来实现；

lazy不能修饰var类型的变量。

使用场景：

打开数据库连接

提升某些特定模块的启动时间

确保对象中的某些字段能优先初始化

def getTotal(a:Int, b:Int) = a + b
lazy val total = getTotal(1, 2) //这里方法不会被执行
println(total) //3, 这里才回值还行方法

5. 方法参数

（1）默认参数：在定义方法时，可以给参数定义一个默认值

def getSum(a:Int = 10, b:Int = 20) = a + b
println(getSum())       //30
println(getSum(50))     //70
println(getSum(b=50))   //60
println(getSum(50, 10)) //60

（2）带名参数

在调用方法时，指定参数名称来进行调用

（3）变长参数

如果方法的参数是不固定的，可以将该方法的参数定义成变长参数

def 方法名(参数名:参数类型*):返回值类型={方法体}

1）在参数后面加一个*，表示该参数可以是0个或多个

2）一个方法有且只有一个变长参数，并且要位于参数列表的最后

def getSum(numbers:Int*)=numbers.sum //numbers底层为数组，scala的数组可以直接求和
println(getSum(1, 2, 3, 4, 5)) //15

6. 方法调用方式

（1）后缀调用法

和java一样，语法如下：

对象名.方法名(参数)

示例：

Math.abs(-1)

（2）中缀调用法

语法格式：

对象名 方法名 参数

示例：

Math abs -1      //等同Math.abs(-1)
Math min(1, 2)   //等同Math.min(1, 2)
1 + 2            //等同 1.+(10)
1 to 10          //等同 1.to(10)

在scala中，操作符也是方法，例如+号是个方法名，是符号的方法

（3）花括号调用法(只能用于只有一个参数的方法)

语法格式：块表达式的返回值作为入参

Math.abs {
    //表达式
}

示例：

Math.abs{
  val a = -11
  if(a > 0) a else -10
} //10

（4）无括号调用法

如果方法没有参数，可以省略方法名后面的括号

示例：

def sayHello() = println("hello world")
sayHello //hello world

***过程

在scala中，如果方法的返回值类型是Unit，这样的方法称为过程（procedure），过程的"="号可以省略不写，例如：

（1）示例1
def sayHello() {println("hello world")}
sayHello //hello world

（2）示例2
def getMax(a:Int, b:Int) {
  val max = if(a >= b) a else b
  println("max value is: " + max)
}

getMax(1, 2) //max value is: 2

5.2 函数

1. 定义函数

val 函数变量名 = (参数名:参数类型, 参数名:参数类型...) => 函数体

1）在scala中，函数是一个对象

2）类似于方法，函数也有参数列表和返回值

3）函数定义不需要使用def

4）无需指定返回值类型

示例：

࿰