1.概述
Scala是一门主要以Java虚拟机(JVM)为目标运行环境并将面向对象和函数式编程语言的最佳特性综合在一起的编程语言。你可以使用Scala编写出更加精简的程序，同时充分利用并发的威力。由于Scala默认运行于JVM之上，因此 它可以访问任何Java类库并且与Java框架进行互操作，比如Scala可以被编译成JavaScript代码，让我们更便捷、高效地开发Web应用。
Scala解释器读到一个表达式，对它进行求值，将它打印出来，接着再继续读下一个表达式。 这个过程被称作“读取-求值-打印”循环(read-eval-print loop),即REPL。
2. Scala基础
- Scala有两种变量，val和var，val类似于Java中的final
1
2
3
| //age可修改、name不可修改
var age = 18
val name = "Tom"
|
1
2
| var age:int = 18
var name:String = "Alice"
|
3.基本类型&&操作
基础类型
![]()
Scala可以兼容Java中的类型，所以字符串类型用的依然是java.lang.String，其他类型均为Scala自己的成员
类型转换
![]()
操作符&&方法
在Scala中任何操作符均为函数，即可调用，也可当做操作符使用
对象相等
由上可知，Scala中所有的操作符均为函数，所以与Java不同的在与，Scala中没有equal函数，全由==，!=代替
4.条件判断
单行if语句
1
2
| var result=if (100>70) true else false
print(result)
|
多行if语句
1
2
3
4
5
| if (100>70){
var result = true
}else{
var result = false
}
|
5. 循环
while循环
1
2
3
4
| var count = 0
while(count < 10){
count += 1
}
|
do-while
1
2
3
4
5
| var count=0
do{
count+=1
println(count)
}while(count<10)
|
for 循环（单行）
1
2
| val arr = Array(1,2,3,4,5)
for(obj <- arr) println("obj:" + obj)
|
for循环（多行）
1
2
3
4
| val arr = Array(1,2,3,4,5)
for(obj <- arr){
println("obj:" + obj)
}
|
函数式
1
2
3
4
5
6
7
8
9
| val arr = Array(1,2,3,4,5)
//逐步省略，Scala会自动识别
arr.foreach((x:Int) => println(x))
//省略类型
arr.foreach(x => println(x))
//省略参数
arr.foreach(println(_))
//省略括号
arr.foreach(println)
|
Range
1
2
3
4
| //输出 1-10
for(i<- 0 to 10) println i
//输出 1-9
for(i<- 0 until 10) println i
|
Filter
1
2
| // 输出 偶数
for(i<- 0 to 10 if i % 2 == 0) println(i)
|
yield
1
2
3
| // 相当于Python中的生成器
val result = for(x<- 0 to 10) yield x*2
result.foreach(println)
|
lazy
1
2
3
| // 懒加载，只有在file被使用时才回去加载资源
lazy val file =new File("demo.txt")
file.mkString
|
匹配表达式
1
2
3
4
5
6
7
| //相当于Java中的Switch
val choice = "1"
choice match{
case "1" => println("选择的是 ：1")
case "2" => println("选择的是 ：2")
case _ => println("选择的是 ：其他")
}
|
6. 函数
Unit函数
1
2
3
4
| // Unit 相当于Java 中的Void
def main(args: Array[String]): Unit = {
println("Hello World")
}
|
单行函数
1
| def demo1(id:Int):String = "my id:"+id.toString
|
头等函数（匿名函数|单行）
1
2
| val dou = (x:Int) => x*x
println(dou(5))
|
头等函数 （多行）
1
2
3
4
| val mul = (x:Int,y:Int) =>{
x*y
}
println(mul(2,3))
|
占位符用法
1
2
3
4
5
6
7
| // 在一个方法中包含另一个方法，里面的方法如果参数只是用一次，则可以用`_`来代替
val arr = Array(1,2,3,4,5,6)
val mul = (x:Int,y:Int) =>{
println(x,y)
x*y
}
println(arr.reduce(mul(_,_)))
|
变长参数
1
2
3
| def demo(id:Int,name:String,others:String*): Unit = {
others.foreach(println)
}
|
7. 类&&对象
辅助构造器&主构造器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| // 主构造器
class User(ids:Int) {
private var id:Int= ids
private var name:String= _
//辅助构造器
def this(id:Int,name:String){
// 当存在主构造器时，辅助构造器可以配合主构造器一起使用
this(id)
this.name=name
}
override def toString: String = {
"id:"+id + "\t name:"+name
}
}
|
方法重写
1
2
3
| override def toString: String = {
name
}
|
先决条件
1
2
3
4
5
6
7
8
9
10
11
12
| class User(ids:Int) {
private var id:Int= ids
private var name:String= _
//先决条件，可以在参数设置之前进行判断
require(id>18)
def this(id:Int,name:String){
this(id)
this.name=name
}
}
|
继承&&特质
继承和Java差不多，都是单继承，但是可以多实现，在scala里面没有接口，只有特质（Trait）
特质的定义除了使用trait关键字之外，与类无异
Object对象
在Java或C++中，通常会用到既有实例方法又有静态方法的类。在Scala中，可以通过类和与类同名的伴生对象来达到同样的目的。
类和它的伴生对象可以相互访问私有特性，但必须存在同一个源文件中
1
2
3
4
5
6
7
8
9
10
11
12
| class User(ids:Int) {
private var id:Int= ids
private var name:String= "Tim"
}
object User{
private var num:Int =0
def getNum():Int={
num+=1
num
}
}
|
数组操作
定长数组
1
2
3
4
5
| //Array 使用（）访问,而不是[]
//创建并初始化
var arr = Array(1,2,3,4,5)
//初始化数组
var arr = Array[String](10)
|
变长数组
1
2
3
4
| import scala.collection.mutable.ArrayBuffer
//变长数组 跟Java ArrayList差不多
val arr = ArrayBuffer[Int](10)
arr+=10
|
映射（Map）
1
2
3
4
5
6
7
8
9
10
11
12
| // 构建 映射
val m = Map("a"->10,"b"->12)
var userList:Map[String,String] = Map()
// 添加新的键值对
userList+=("a"-> "123")
userList("b")="333"
// 获取对应值
println(m.get("a"))
//便利 映射
m.keys.foreach(println)
m.values.foreach(println)
m.foreach(println)
|
元组
元组是不同类型值的集合，和Python一样不可修改
1
2
3
4
5
| //初始化元组，不指定元组个数，Scala会自动识别
val t1=(1,2,3)
val t2=Tuple3(2,3,4)
//输出
println(t1._1,t1._2,t1._3)
|
样例类
快速建立一些简单的类
1
2
3
4
5
| object Objects {
case class Message(Content:String,Sender:Actor)
case class User(userName:String,password:String)
case class Message1(countent:String,flag:Boolean)
}
|
泛型
1
2
3
4
| class Pair[K,V](val k:K,val v:V){
var key=k
var value=v
}
|
隐式转换
略…
Actor并发编程
Scala中的Actor是一种不共享数据，依赖于消息传递的一种并发编程模式，避免了死锁、资源争夺的情况。
Scala中的Actor会不断循环自己的邮箱，并通过receive偏函数进行消息的模式匹配并进行相应的处理。如果Actor A与Actor B需要相互通信，首先A要给B发送一个消息，B会有一个收件箱，然后B会不断循环自己的收件箱，若看见A发送的消息，B就会解析A的消息并执行，处理完后将结果以邮件的方式发送给A。
一个简单的Actor Demo
1
2
3
4
5
6
7
8
9
10
11
12
13
| // 使用Actor只需要继承一个Actor类，并实现act()方法即可
class ActorDemo extends Actor{
override def act(): Unit = {
receive{
case msg:String => println("Message: "+ msg)
}
}
}
//主类调用
val a1=new ActorDemo
a1.start
a1 ! "Hello？"
|
两个Actor之间的交互
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| //只需要将需要交互的Actor在发送信息的时候带上自己即可
class ActorDemo1(name:String) extends Actor{
override def act(): Unit = {
while (true){
receive{
case Message(cont,send)=>{
println(name+" receive message :"+ cont)
val str = readLine(name+" send message : ")
send ! Message(str,this)
}
}
}
}
}
//主类调用
val a2 = new ActorDemo1("小王")
val a3 = new ActorDemo1("小张")
|
