一、Scala 简介
1、Scala语言既可用于大规模应用程序开发，也可以用于脚本编程，2001年由Martin Odersk 开发，主要优势 速度和它的表达性。一门函数式编程语言，既有面向对象的特点，又有面向过程的特点。
2、Scala与Java关系：Scala代码需要经过编译为字节码，然后交由Java虚拟机来运行，可以任意调用就Java的代码。所以Scala也就是JVM的一门编程语言。
3、安装Scala版本:scala-2.11.8msi; 进入cmd 下输入scala,进入Scala编程； scala -version 查看Scala版本
二、Scala基础
1、Scala解释器：进入安装Scala目录下——bin目录，运行scala.bat
scala解释器也被成为REPL（Read取值——Evalution求值——Print打印——Loop循环），会快速编译scala代码为字节码，然后交给JVM来执行。
在scala>命令行内，键入代码，解释器会直接返回结果，如果没有指定变量来存放这个值，那么值默认名称为res，而且会显示结果数据类型。
例：输入1+1，会看到res0:Int =2
内置变量：在后面还可以继续使用res这变量，以及它存放的值 例：“hi,”+res0,返回res2：String =hi,2
自动补全：在scala>命令行时，可以使用Tab键进行自动补全
2、声明变量
声明常量： val result=1+1 声明后无法改变它的值 例：result=3（报错）
声明变量：var result=2，result=3 声明值可以改变引用 （建议使用val,在网络传输数据时，防止被错误的更改）
声明变量时，可以手动指定类型，也不可以不指定，scala会根据值进行类型推断，也可以将多个变量放在一起声明 例：val n1,n2 = 100 val na1,na2:String = null
3、数据类型与操作符
基本数据类型：Byte、 Char、 Short、 Int、 Long、 Float、 Double、 Boolean。 （与Java不同的是首字母大写） scala数据类型统一都是类，scala自己负责基本数据类型与引用类型转换
使用以上类型， 直接就可以调用大量的函数， 例如， 1.toString()， 1.to(10) 结果是1到10 的一个集合
类型的加强版类型： Scala使用很多加强类给数据类型增加了上百种增强的功能或函数。
基本操作符： Scala的算术操作符与Java的算术操作符也没有什么区别， 比如+、 -、 *、 /、 %等， 以及&、 |、 ^、 >>、 <<等。
但是， 在Scala中， 这些操作符其实是数据类型的函数， 比如1 + 1， 可以写做1.+(1)
例如， 1.to(10)， 又可以写做1 to 10
Scala中没有提供++、 --操作符， 我们只能使用+和-， 比如counter = 1， counter++是错误的， 必须写做counter += 1。
4、调用函数
除了方法之外，Scala还提供函数 ；import scala.math._ ,_是通配符，类似Java中的*
import scala.math._ sqrt(2)
三、控制结构、循环与函数
1、if表达式的定义： 在Scala中， if表达式是有值的， 就是if或者else中最后一行语句返回的值。
例如， val age = 30; if (age > 18) 1 else 0
可以将if表达式赋予一个变量， 例如， val isAdult = if (age > 18) 1 else 0
if表达式的类型推断： 由于if表达式是有值的， 而if和else子句的值类型可能不同， 此时Scala会自动进行推断， 取两个类型的公共父类型。
例：if(age > 18) 1 else 0， 表达式的类型是Int， 因为1和0都是Int
例：if(age > 18) "adult" else 0， 此时if和else的值分别是String和Int， 则表达式的值是Any， Any是String和Int的公共父类型
如果if后面没有跟else， 则默认else的值是Unit， 也用()表示， 类似于Java中的void或者null。 例如， val age = 12; if(age > 18) "adult"。 此时就相当于if(age > 18) "adult" else ()
将if语句放在多行中： 默认情况下， REPL只能解释一行语句， 但是if表达式通常需要放在多行。 可以使用{}的方式， 比如以下方式， 或者使用:paste和ctrl+D的方式。
例：
if(age > 18) { "adult"
} else if(age > 12) "teenager" else "children"
2、语句终结符、块表达式
默认情况下， Scala不需要语句终结符， 默认将每一行作为一个语句
一行放多条语句： 如果一行要放多条语句， 则必须使用语句终结符 例如， 使用分号作为语句终结符， var a, b, c = 0; if(a < 10) { b = b + 1; c = c + 1 }
对于多行语句， 还是会使用花括号的方式
块表达式： 块表达式， 指的就是{}中的值， 其中可以包含多条语句， 最后一个语句的值就 是块表达式的返回值。 例val d= if（a>10）{"a";"b"} 返回的是b
3、输入输出
print和println： print打印时不会加换行符， 而println打印时会加一个换行符。
printf： printf可以用于进行格式化 例如， printf("Hi, my name is %s, I'm %d years old.\n", "Leo", 30)
readLine: readLine允许我们从控制台读取用户输入的数据， 类似于Java 中的System.in和Scanner的作用。
输入输出案例：
val name = readLine("Welcome to Game House. Please tell me your name: ")
print("Thanks. Then please tell me your age: ")
val age = readInt()
if(age > 18) {
printf("Hi, %s, you are %d years old, so you are legel to come here!", name, age)
} else {
printf("Sorry, boy, %s, you are only %d years old. you are illegal to come here!",
name, age)
}
4、循环
（1）Scala拥有与Java相同的while和do-while循环 ，但没有与for(初始化变量;判断条件;更新变量)循环直接对应的对构 ，Scala中的for: for(i<-表达式)，让变量i遍历<-右边表达式的所有值。
注意：在for循环的变量之前并没有val或var的指定，该变量的类型是集合的 元素类型。 循环变量的作用域一直持续到循环结束。
（2）until方法返加一个不包含上限的区间 var sum =0;for(i<-0 until 10) sum+=i 区间是0到9，不包含10
直接遍历 val content="hello";for(c<- content) print(c+" ")
(3)可以变量<-表达式的形式提供多个生成器，用分号将它们隔开 例：for（i<-1 to 3;j<- 1 to 3）print((10*i+j)+" ")
for循环中添加过滤条件if语句，即为守卫式。 例：for（i<-1 to 3;j<- 1 to 3 if i !=j）print((10*i+j)+" ")
(4)在循环中使用变量 例：for(i<-1 to 3;from =4-i;j<-from to 3) print((10*i+j)+" ")
推导式：如果for循环的循环体以yield开始，则该循环会构造出一个 集合，每次迭代生成集合中的一个值。
例：for(i<- 1 to 10) yield i%3 生成Vector(1,2,0,1,2,0,1,2,0,1)
5、（1）高级for循环
多重for循环： 九九乘法表
for(i <- 1 to 9; j <- 1 to 9) {
if(j == 9) {
println(i * j)
} else {
print(i * j + " ")
}
}
if守卫： 取偶数 for(i <- 1 to 100 if i % 2 == 0) println(i)
for推导式： 构造集合 for(i <- 1 to 10) yield i
（2）在代码块中定义包含多行语句的函数体
单行函数：def a(name:String) =print("hello,"+name)
如果函数体中有多行代码， 则可以使用代码块的方式包裹多行代码， 代码块中最后一行的 返回值就是整个函数的返回值。 与Java中不同， 不是使用return返回值的。
def sum(n: Int) :Int= {
var sum = 0
for(i <- 1 to n) sum += i
sum
}
:Int返回值的类型
（3）函数的定义与调用
在Scala中定义函数时， 需要定义函数的函数名、 参数、 函数体
Scala要求必须给出所有参数的类型， 但是不一定给出函数返回值的类型。 只要右侧的函数体中不包含递归的语句， Scala就可以自己根据右侧的表达式推断出返回类型。
def sayHello(name: String, age: Int) = {
if (age > 18) { printf("hi %s, you are a big boy\n", name); age }
else { printf("hi %s, you are a little boy\n", name); age
} s
ayHello("leo", 30)
（4）递归函数与返回类型
如果在函数体内递归调用函数自身， 则必须给出函数的返回类型 。 例如实现经典的斐波那契数列： 9 + 8; 8 + 7 + 7 + 6; 7 + 6 + 6 + 5 + 6 + 5 + 5 + 4; ....
def fab(n: Int): Int = {
if(n <= 2) 1
else fab(n - 1) + fab(n - 2)
}
（5）默认参数
在Scala中， 有时我们调用某些函数时， 不希望给出参数的具体值， 而希望使 用参数自身默认的值， 此时就定义在定义函数时使用默认参数。 如果给出的参数不够， 则会从左往右依次应用参数。
例：def sayHello(firstName: String, middleName: String = "William", lastName: String = "Croft") = firstName + " " + middleName + " " + lastName
（6）Java与Scala实现默认参数的区别
Java：
public void sayHello(String name, int age) {
if(name == null) {
name = "defaultName"
} if
(age == 0) {
age = 18
}
} s
ayHello(null, 0)
scala：
def sayHello(name: String, age: Int = 20) {
print("Hello, " + name + ", your age is " + age)
} s
ayHello("leo")
（7）带名参数
在调用函数时， 也可以不按照函数定义的参数顺序来传递参数， 而是使用带名参数的方式来 传递。
sayHello(firstName = "Mick", lastName = "Nina", middleName = "Jack")
还可以混合使用未命名参数和带名参数， 但是未命名参数必须排在带名参数前面。
sayHello("Mick", lastName = "Nina", middleName = "Jack")
（8）使用序列调用变长参数
在如果要将一个已有的序列直接调用变长参数函数， 是不对的。 比如val s = sum(1 to 5)。 此时需要使用Scala特殊的语法将参数定义为序列， 让Scala解释器能够识别。
val s = sum(1 to 5: _*) 通过 :_*转换成参数序列
例：使用递归函数实现累加
def sum2(nums: Int*): Int = {
if (nums.length == 0) 0
else nums.head + sum2(nums.tail: _*)
}
Int* :变长参数（参数长度可变） head取出集合第一个元素 tail 取出第一个剩下的元素
6、函数——过程、 lazy值和异常
过程：在Scala中， 定义函数时， 如果函数体直接包裹在了花括号里面， 而没有使用=连接， 则函数的返回值类型就是Unit， 这样的函数就被称之为过程。 过程通常用于不需要返回值的函数。
过程还有一种写法， 就是将函数的返回值类型定义为Unit。
例：def sayHello(name: String) = "Hello, " + name
def sayHello(name: String) { print("Hello, " + name); "Hello, " + name }
def sayHello(name: String): Unit = "Hello, " + name
lazy：在Scala中， 提供了lazy值的特性， 也就是说， 如果将一个变量声明为lazy， 则只有在第一次使用 该变量时， 变量对应的表达式才会发生计算。 这种特性对于特别耗时的计算操作特别有用，
比如打开文件进行IO， 进行网络IO等。
import scala.io.Source._
lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
即使文件不存在， 也不会报错， 只有第一次使用变量时会报错， 证明了表达式计算的lazy特性。
val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString 与lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString的比较
lazy声明的这行代码并没有被执行，当调用lines时才被执行，lazy是spark scala中很重要的特性
异常：在Scala中， 异常处理和捕获机制与Java是非常相似的。
例：
try {
throw new IllegalArgumentException("x should not be negative")
} catch {
case _: IllegalArgumentException => println("Illegal Argument!")
} finally {
print("release resources!")
}
或者
try {
throw new IOException("user defined exception")
} catch {
case e1: IllegalArgumentException => println("illegal argument")
case e2: IOException => println("io exception")
}
四、数组
1、数组
若长度固定使用Array，若长度不固定则使用ArrayBuffer
定长数组 val nums=new Array[Int](10); //10个整数的数组 或者 val str =Array("hello","world")
String 默认值是null Int默认值0 Boolean 默认值 是false ，取值时 数组用（），JAVA用[]
2、变长数组：数组缓冲
对于那种长度按需要变化的数组，Java有ArrayList，Scala有 ArrayBuffer
例：val arr=ArrayBuffer[Int]() 先导入包 scala.collection.mutable.ArrayBuffer
arr +=1 添加元素
arr++=Array(5,3,2) 添加元素
arr.trimEnd(5) 删除从后往前数5个
arr.insert(2,6) 第一个代表索引，剩下为添加的元素（在第三个数前添加6）
arr.remove(2,3) 第一个代表索引，第二个是个数（移除三个数，从第三个开始依次往后）
3、变长数组与定长数组之间的转换
变长数组→定长数组：.toArray 定长数组→变长数组：.toBuffer 对原数组没有影响，只是构建新的集合
4、遍历数组
for（i<-0 until arr.length） print(arr(i)+" ")
for(i<-(0 until arr.length).reverse) print(arr(i)+" ") 数组中的元素从后往前依次输出
for （i<-0 until (arr.length,2)） print(arr(i)+" ") 跳跃输出，长度为2，例：原数组 （1,2，3，4,5） 结果（1,3,5）
5、数组常用算法
arr.sum 求和 arr.max 求最大值 arr.min 最小值
val arrs=arr.sorted 对arr数组进行排序
val arrs=arr.sortWith(_>_) 降序排序
val arrs=arr.sortwith(_<_) 升序排序
arrs.mkString("and") arrs.mkString("&&") mkString方法允许指定元素之间的分隔符
五、补充
1、接口在scala中不存在， 函数存在不依赖类，方法依赖于类
2、实现直接三角形
for(i<-1 to 5;temp=2*i-1;j<-1 to temp){
print("*")
if(j==temp)println()
}
3、递归函数:自身调用自身
def fn(n:Int):Int{
if(n>0&&n<=1) 1
else n*fn(n-1)
}
4、十进制转换成二进制
十进制6转换成二进制，6除以2等3余0 ，3除以2等1余1，1除以2等0余1，所以转换成二进制是 00000110 （总共8位，余数倒着来）
5、面向对象三大特性