Scala(下)
一，集合
1.1 数组
- 创建数组
val a = new Array(Int)(5) ##定义一个元素为Int类型，长度为5的数组
a(0) = 1 ##赋值
a(1) = 2
a(2) = 3
val b = Array("s1","s2","s3") ##定义数组另一种方式
- 数组遍历
//for
val a = new Array(Int)(5) ##定义一个元素为Int类型，长度为5的数组
a(0) = 1 ##赋值
a(1) = 2
a(2) = 3
for(i<- a){
println(i)
}
//foreach
a.foreach(i=> {println(i)} )
a.foreach(println) ##简写
- 创建二维数组
var arr = new Array(Array[String])(3) ##创建一个长度为3的二维数组，存储的数组类型是String
arr(0) = Array("a","b","c")
arr(1) = Array("d","e","f")
arr(2) = Array("g")
//for
for(i<- arr; j<- i){
println(j)
}
//foreach
arr.foreach(i=> {
i.foreach(j=> { println(j) })
})
val arr2 = Array(Array(1,2,3),Array(4,5,6)) ##第二种定义方式
数组常用方式：
序号-方法-描述
1
def apply( x: T, xs: T* ): Array[T]
创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
2
def concat[T]( xss: Array[T]* ): Array[T]
合并数组
3
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
复制一个数组到另一个数组上。相等于 Java's System.arraycopy(src, srcPos, dest, destPos, length)。
4
def empty[T]: Array[T]
返回长度为 0 的数组
5
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值。
以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1：
scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)
6
def fill[T]( n: Int )(elem: => T): Array[T]
返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
7
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]
返回二数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
8
def ofDim[T]( n1: Int ): Array[T]
创建指定长度的数组
9
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
创建二维数组
10
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
创建三维数组
11
def range( start: Int, end: Int, step: Int ): Array[Int]
创建指定区间内的数组，step 为每个元素间的步长
12
def range( start: Int, end: Int ): Array[Int]
创建指定区间内的数组
13
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。
以上实例返回 3 个元素：
scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)
14
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。
1.2 list
- 创建list
val list = List(1,2,3,4) ## Nil是长度为0的list
- list遍历
//for
val list = List(1,2,3,4)
for (i<- list){println(i)}
//foreach
list.foreach(i=>{println(i)})
list.foreach(println)
- list方法
filter : 过滤元素
count : 计算符合条件的元素个数
map : 对元素操作
flatmap : 压扁扁平，先map再flat
//创建
val list = List(1,2,3,4)
//filter
val list01 = list.filter(x=> x>3)
list01.foreach(println)
//count
val n = list.count(x=> x>3)
println(n)
//map
val list2 = List("hello world","hello cat","hello tom")
val list03 = list2.map(x=> x.spilt(" "))
list02.foreach(println)
//flatmap
val list04 = list2.flatmap(x=> x.spilt(" "))
list04.foreach(println)
list常用方法:
1 def +(elem: A): List[A]
前置一个元素列表
2 def ::(x: A): List[A]
在这个列表的开头添加的元素。
3 def :::(prefix: List[A]): List[A]
增加了一个给定列表中该列表前面的元素。
4 def ::(x: A): List[A]
增加了一个元素x在列表的开头
5 def addString(b: StringBuilder): StringBuilder
追加列表的一个字符串生成器的所有元素。
6 def addString(b: StringBuilder, sep: String): StringBuilder
追加列表的使用分隔字符串一个字符串生成器的所有元素。
7 def apply(n: Int): A
选择通过其在列表中索引的元素
8 def contains(elem: Any): Boolean
测试该列表中是否包含一个给定值作为元素。
9 def copyToArray(xs: Array[A], start: Int, len: Int): Unit
列表的副本元件阵列。填充给定的数组xs与此列表中最多len个元素，在位置开始。
10 def distinct: List[A]
建立从列表中没有任何重复的元素的新列表。
11 def drop(n: Int): List[A]
返回除了第n个的所有元素。
12 def dropRight(n: Int): List[A]
返回除了最后的n个的元素
13 def dropWhile(p: (A) => Boolean): List[A]
丢弃满足谓词的元素最长前缀。
14 def endsWith[B](that: Seq[B]): Boolean
测试列表是否使用给定序列结束。
15 def equals(that: Any): Boolean
equals方法的任意序列。比较该序列到某些其他对象。
16 def exists(p: (A) => Boolean): Boolean
测试谓词是否持有一些列表的元素。
17 def filter(p: (A) => Boolean): List[A]
返回列表满足谓词的所有元素。
18 def forall(p: (A) => Boolean): Boolean
测试谓词是否持有该列表中的所有元素。
19 def foreach(f: (A) => Unit): Unit
应用一个函数f以列表的所有元素。
20 def head: A
选择列表的第一个元素
21 def indexOf(elem: A, from: Int): Int
经过或在某些起始索引查找列表中的一些值第一次出现的索引。
22 def init: List[A]
返回除了最后的所有元素
23 def intersect(that: Seq[A]): List[A]
计算列表和另一序列之间的多重集交集。
24 def isEmpty: Boolean
测试列表是否为空
25 def iterator: Iterator[A]
创建一个新的迭代器中包含的可迭代对象中的所有元素
26 def last: A
返回最后一个元素
27 def lastIndexOf(elem: A, end: Int): Int
之前或在一个给定的最终指数查找的列表中的一些值最后一次出现的索引
28 def length: Int
返回列表的长度
29 def map[B](f: (A) => B): List[B]
通过应用函数以g这个列表中的所有元素构建一个新的集合
30 def max: A
查找最大的元素
31 def min: A
查找最小元素
32 def mkString: String
显示列表的字符串中的所有元素
33 def mkString(sep: String): String
显示的列表中的字符串中使用分隔串的所有元素
34 def reverse: List[A]
返回新列表，在相反的顺序元素
35 def sorted[B >: A]: List[A]
根据排序对列表进行排序
36 def startsWith[B](that: Seq[B], offset: Int): Boolean
测试该列表中是否包含给定的索引处的给定的序列
37 def sum: A
概括这个集合的元素
38 def tail: List[A]
返回除了第一的所有元素
39 def take(n: Int): List[A]
返回前n个元素
40 def takeRight(n: Int): List[A]
返回最后n个元素
41 def toArray: Array[A]
列表以一个数组变换
42 def toBuffer[B >: A]: Buffer[B]
列表以一个可变缓冲器转换
43 def toMap[T, U]: Map[T, U]
此列表的映射转换
44 def toSeq: Seq[A]
列表的序列转换
45 def toSet[B >: A]: Set[B]
列表到集合变换
46 def toString(): String
列表转换为字符串
1.3 Set
- 创建Set
//定义Set
val set = Set(5,7)
val set1 = Set(5,7,8,10)
- 遍历Set
//遍历，set集合会自动去重
set.foreach(println)
- 相关方法
//对两个set取交集
val ints = set.intersect(set1)
ints.foreach(println(_))
val bset = set.&(set1) //和 intersect方法效果相同
// bset.foreach(println)
//前一个set对后一个set取差集
val cset = set.diff(set1)
cset.foreach(println)
set1.&~(set).foreach(println) //和 diff方法效果相同
//判断前一个set 是不是后一个set的子集
val b: Boolean = set.subsetOf(set1)
println(b)
println(set.max) //取set中的最大值
println(set.min) //去set中的最小值
set.toArray.foreach(println) //将set转换为数组
set.toList.foreach(println) //将set转换为list
println(set.mkString) //将set元素拼接为字符串
println(set.mkString(" "))
val set3 = set.+(5)
- Set常用方法
Scala Set 常用方法
下表列出了 Scala Set 常用的方法：
序号 方法及描述
1
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
2
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
3
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
4
def &(that: Set[A]): Set[A]
返回两个集合的交集
5
def &~(that: Set[A]): Set[A]
返回两个集合的差集
6
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
7
def ++(elems: A): Set[A]
合并两个集合
8
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
9
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
10
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11
def apply(elem: A)
检测集合中是否包含指定元素
12
def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
13
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
14
def diff(that: Set[A]): Set[A]
比较两个集合的差集
15
def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
16
def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
17
def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
18
def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
19
def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
20
def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
21
def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
22
def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
23
def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
24
def head: A
获取不可变集合的第一个元素
25
def init: Set[A]
返回所有元素，除了最后一个
26
def intersect(that: Set[A]): Set[A]
计算两个集合的交集
27
def isEmpty: Boolean
判断集合是否为空
28
def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
29
def last: A
返回最后一个元素
30
def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
31
def max: A
查找最大元素
32
def min: A
查找最小元素
33
def mkString: String
集合所有元素作为字符串显示
34
def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
35
def product: A
返回不可变集合中数字元素的积。
36
def size: Int
返回不可变集合元素的数量
37
def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否则返回false
39
def sum: A
返回不可变集合中所有数字元素之和
40
def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
41
def take(n: Int): Set[A]
返回前 n 个元素
42
def takeRight(n: Int):Set[A]
返回后 n 个元素
43
def toArray: Array[A]
将集合转换为数组
44
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
45
def toList: List[A]
返回 List，包含了不可变集合的所有元素
46
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
47
def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
48
def toString(): String
返回一个字符串，以对象来表示
1.4 Map
- 创建Map
//map的创建
val map = Map(1-> "a",2-> "b","3"-> "c")
val map01 = Map(("a",1),("b",2),("c",3))
注意：创建map时，相同的key被后面的相同的key顶替掉，只保留一个
- 获取map的值
//获取map的值
val valueOption: Option[String] = map.get(1)
val value: String = valueOption.get
//println(value)
val value01 = map.get("3").get
//println(value01)
//val value02 = map.get("8").get => 会报错
// println(value02)
val value03 = map.get("8").getOrElse("no value")
//println(value03) => 打印 no value
- 遍历map
var keyIterable = map.keys //获取map的key
keyIterable.foreach(key=> {
// println(key+" "+map.get(key).get)
})
map01.foreach(f=>{
println("key:"+f._1+" value:"+f._2)
})
for (i<- map){
println("key:"+i._1+"value:"+i._2)
}
val values: Iterable[String] = map.values //获取map的value
values.foreach(println)
- 合并Map
val map1 = Map(
(1,"a"),
(2,"b"),
(3,"c")
)
val map2 = Map(
(1,"aa"),
(2,"bb"),
(3,98),
(4,22),
(4,"dd")
)
val map3: Map[Int, Any] = map2.++(map1)
map3.foreach(println)
- map常用方法
val b: Map[Int, String] = map1.filter(p=>{ //根据条件过滤map
p._2.equals("a")
})
b.foreach(println)
println(map1.contains(1)) //判断map是否包含指定的key
val a: Boolean = map.exists(p=>{ //判断map指定条件的元素是否存在
p._2.equals("a")
})
println(a)
- map常见方法列举
Scala Map 方法
下表列出了 Scala Map 常用的方法：
序号 方法及描述
1
def ++(xs: Map[(A, B)]): Map[A, B]
返回一个新的 Map，新的 Map xs 组成
2
def -(elem1: A, elem2: A, elems: A*): Map[A, B]
返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。
3
def --(xs: GTO[A]): Map[A, B]
返回一个新的 Map, 移除 xs 对象中对应的 key
4
def get(key: A): Option[B]
返回指定 key 的值
5
def iterator: Iterator[(A, B)]
创建新的迭代器，并输出 key/value 对
6
def addString(b: StringBuilder): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
7
def addString(b: StringBuilder, sep: String): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
8
def apply(key: A): B
返回指定键的值，如果不存在返回 Map 的默认方法
10
def clone(): Map[A, B]
从一个 Map 复制到另一个 Map
11
def contains(key: A): Boolean
如果 Map 中存在指定 key，返回 true，否则返回 false。
12
def copyToArray(xs: Array[(A, B)]): Unit
复制集合到数组
13
def count(p: ((A, B)) => Boolean): Int
计算满足指定条件的集合元素数量
14
def default(key: A): B
定义 Map 的默认值，在 key 不存在时返回。
15
def drop(n: Int): Map[A, B]
返回丢弃前n个元素新集合
16
def dropRight(n: Int): Map[A, B]
返回丢弃最后n个元素新集合
17
def dropWhile(p: ((A, B)) => Boolean): Map[A, B]
从左向右丢弃元素，直到条件p不成立
18
def empty: Map[A, B]
返回相同类型的空 Map
19
def equals(that: Any): Boolean
如果两个 Map 相等(key/value 均相等)，返回true，否则返回false
20
def exists(p: ((A, B)) => Boolean): Boolean
判断集合中指定条件的元素是否存在
21
def filter(p: ((A, B))=> Boolean): Map[A, B]
返回满足指定条件的所有集合
22
def filterKeys(p: (A) => Boolean): Map[A, B]
返回符合指定条件的的不可变 Map
23
def find(p: ((A, B)) => Boolean): Option[(A, B)]
查找集合中满足指定条件的第一个元素
24
def foreach(f: ((A, B)) => Unit): Unit
将函数应用到集合的所有元素
25
def init: Map[A, B]
返回所有元素，除了最后一个
26
def isEmpty: Boolean
检测 Map 是否为空
27
def keys: Iterable[A]
返回所有的key/p>
28
def last: (A, B)
返回最后一个元素
29
def max: (A, B)
查找最大元素
30
def min: (A, B)
查找最小元素
31
def mkString: String
集合所有元素作为字符串显示
32
def product: (A, B)
返回集合中数字元素的积。
33
def remove(key: A): Option[B]
移除指定 key
34
def retain(p: (A, B) => Boolean): Map.this.type
如果符合满足条件的返回 true
35
def size: Int
返回 Map 元素的个数
36
def sum: (A, B)
返回集合中所有数字元素之和
37
def tail: Map[A, B]
返回一个集合中除了第一元素之外的其他元素
38
def take(n: Int): Map[A, B]
返回前 n 个元素
39
def takeRight(n: Int): Map[A, B]
返回后 n 个元素
40
def takeWhile(p: ((A, B)) => Boolean): Map[A, B]
返回满足指定条件的元素
41
def toArray: Array[(A, B)]
集合转数组
42
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了 Map 的所有元素
43
def toList: List[A]
返回 List，包含了 Map 的所有元素
44
def toSeq: Seq[A]
返回 Seq，包含了 Map 的所有元素
45
def toSet: Set[A]
返回 Set，包含了 Map 的所有元素
46
def toString(): String
返回字符串对象
1.5 元组
- 元组定义
与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。
//创建元组，最多支持 22个
val tuple = Tuple1(1,2)
val tuple1: (Int, Int) = Tuple2(3,4)
val tuple2 = Tuple2( (1,2), ("name","zhangsan") )
- 创建元组与取值
val tuple = new Tuple（1） 可以使用new
val tuple2 = Tuple（1,2） 可以不使用new，也可以直接写成
val tuple3 =（1,2,3）
取值用”._XX” 可以获取元组中的值
注意：tuple最多支持22个参数
- 元组遍历
//获取迭代器
val c: Iterator[Any] = tuple1.productIterator
// while(c.hasNext){
// println(c.next())
// }
c.foreach(println)
- swap,toString方法
//翻转，只针对二元组
println(tuple1.swap)
//toString
println(tuple2.toString())
二，Trait特性
2.1 概念理解
Scala Trait(特征)相当于Java的接口，实际上它比接口功能还强大。
和接口不同的是，它还可以定义属性和方法的实现
一般情况下Scala的类可以继承多个Trait，从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。
- trait中带属性带方法实现
注意：集合的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。
trait中不可以传参数。
package com.shsxt.scala.demo
//不可以传参数
trait Read{
val name = "read"
def read(name: String)={
println(name+"is reading.....")
}
}
trait Listen{
val name = "listening"
def listen(name:String): Unit ={
println(name+"is listen...........")
}
}
//多 extends
class Person extends Read with Listen{
//同名属性，加关键字 override
override val name = "wcb"
}
object scala_Trait {
def main(args: Array[String]): Unit = {
val p1 = new Person()
println(p1.name)
p1.read("wcb")
p1.listen("wcb")
}
}
- trait中带方法不实现
package com.shsxt.scala.demo
trait Equle{
def isEqule(x:Point):Boolean //为实现方法需声明返回值类型
def isNotEqule(x:Point) = {
!isEqule(x)
}
}
class Point(x:Int,y:Int) extends Equle {
val xx =x
val yy = y
def isEqule(p: Point): Boolean = {
p.xx==xx & p.yy==yy
}
}
object scala_TraitTwo {
def main(args: Array[String]): Unit = {
val p1 = new Point(3,4)
val p2 = new Point(3,3)
println(p1.isEqule(p2)) //false
println(p1.isNotEqule(p2)) //true
}
}
三，模式匹配match
3.1 概念理解
类似于java中的 switch
Scala 提供了强大的模式匹配机制，应用也非常广泛。
一个模式匹配包含了一系列备选项，每个都开始于关键字 case。
每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。
3.2 注意点
- 模式匹配不仅可以匹配值还可以匹配类型
- 从上到下顺序匹配，如果匹配到则不再往下匹配
- 都匹配不上时，会匹配到case _ ,相当于java中的 default
- match的最外面的“ {} ”可以去掉看成一个语句
package com.shsxt.scala.demo
object scala_Match {
def main(args: Array[String]): Unit = {
val tuple = Tuple6(1,2,3f,4,"abc",55d)
val tupleIterator = tuple.productIterator
while(tupleIterator.hasNext){
matchTest(tupleIterator.next())
}
}
def matchTest(x:Any) ={
x match {
case x:Int => println("type is Int")
case 1 => println("result is 1")
case 2 => println("result is 2")
case 3 => println("result is 3")
case 4 => println("result is 4")
case x:String => println("type is string")
case _ => println("no match")
}
}
/**
* 输出结果
* type is Int
type is Int
result is 3
type is Int
type is string
no match
*/
}
四，样例类(case classes)
4.1 概念
使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类。实现了类构造参数的getter方法（构造参数默认被声明为val），当构造参数是声明为var类型的，它将帮你实现setter和getter方法。
-
样例类默认帮你实现了toString,equals，copy和hashCode等方法。
-
样例类可以new, 也可以不用new
4.2 例子
package com.shsxt.scala.demo
//样例类
case class Person01(name:String,age:Int)
object scala_CaseClass {
def main(args: Array[String]): Unit = {
val p1 = new Person01("wcb",18)
val p2 = Person01("xixi",20)
val p3 = Person01("lisi",25)
var list = List(p1,p2,p3)
list.foreach(x=> {
x match {
case Person01("xixi",20) => println("xixi")
case x:Person01 => println("type is person01...")
case _ => println("no value....")
}
})
}
}
五，Actor Model
5.1 概念
Actor Model是用来编写并行计算或分布式系统的高层次抽象（类似java中的Thread）让程序员不必为多线程模式下共享锁而烦恼,被用在Erlang 语言上, 高可用性99.9999999 % 一年只有31ms 宕机Actors将状态和行为封装在一个轻量的进程/线程中，但是不和其他Actors分享状态，每个Actors有自己的世界观，当需要和其他Actors交互时，通过发送事件和消息，发送是异步的，非堵塞的(fire-andforget)，发送消息后不必等另外Actors回复，也不必暂停，每个Actors有自己的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，可以建立性能很好的事件驱动系统。
5.2 Actor的特征
- ActorModel是消息传递模型，基本特征就是消息传递
- 消息发送是异步的，非阻塞的
- 消息一旦发送成功，不能修改
- Actor之间传递时，自己决定是否去检查消息，而不是一直等待，是异步非阻塞的
5.3 Akka
Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和Scala 的 Actor 模型应用，底层实现就是Actor,Akka是一个开发库和运行环境，可以用于构建高并发、分布式、可容错、事件驱动的基于JVM的应用。使构建高并发的分布式应用更加容易。
spark1.6版本之前，spark分布式节点之间的消息传递使用的就是Akka，底层也就是actor实现的。1.6之后使用的netty传输。
5.4 代码
- Actor发送接收消息
package com.shsxt.scala.demo
import scala.actors.Actor
class MyActor extends Actor{
override def act(): Unit = {
while (true){
receive {
case x:String => println("save String="+x)
case x:Int => println("save Int")
case _ => println("save default")
}
}
}
}
object scala_Actor {
def main(args: Array[String]): Unit = {
val actor = new MyActor()
actor.start()
actor ! "i love you"
actor ! 2
}
}
- Actor之间相互通信
package com.shsxt.scala.demo
import scala.actors.Actor
case class Message(actor:Actor,msg:String)
class Actor1 extends Actor{
override def act(): Unit = {
while (true){
receive {
case msg:Message => {
println("i save msg! = "+msg.msg)
msg.actor ! "i love you too"
}
case msg:String => println(msg)
case _ => println("............")
}
}
}
}
class Actor2(actor: Actor) extends Actor{
override def act(): Unit = {
while (true){
receive {
case msg:String => {
if (msg.equals("l love you too")){
println(msg)
}
actor ! "could we have a date"
}
case _ => {
println("..........")
}
}
}
}
}
object scala_actorMes {
def main(args: Array[String]): Unit = {
val a1 = new Actor1()
val a2 = new Actor2(a1)
a1.start()
a2.start()
val msg = Message(a2,"l love you")
a1 ! msg
}
}