【Scala学习之二】 Scala 集合 Trait Actor

时间 2019-12-02 标签 Scala学习之二 scala 集合 trait actor

环境
　　虚拟机：VMware 10
　　Linux版本：CentOS-6.5-x86_64
　　客户端：Xshell4
　　FTP：Xftp4
　　jdk1.8
　　scala-2.10.4(依赖jdk1.8)
spark-1.6java

1、字符串、数组、List、Set、Map、tuple程序员

tuple
一、元组定义
与列表同样，与列表不一样的是元组能够包含不一样类型的元素。元组的值是经过将单个的值包含在圆括号中构成的。
二、建立元组与取值
val tuple = new Tuple（1）可使用new
val tuple2 = Tuple（1,2）能够不使用new，也能够直接写成val tuple3 =（1,2,3）
取值用”._XX” 能够获取元组中的值
注意：tuple最多支持22个参数shell

val tuple = new Tuple1(1)
val tuple2 = Tuple2("zhangsan",2)
val tuple3 = Tuple3(1,2,3)
val tuple4 = (1,2,3,4)
val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)

//使用
println(tuple2._1 + "\t"+tuple2._2)
val t = Tuple2((1,2),("zhangsan","lisi"))
println(t._1._2)

三、元组的遍历数组

tuple.productIterator获得迭代器，进而遍历

val tupleIterator = tuple22.productIterator
while(tupleIterator.hasNext){
println(tupleIterator.next())
}

四、swap,toString方法
注意：swap元素翻转，只针对二元组多线程

//翻转，只针对二元组
println(tuple2.swap)

//toString
println(tuple3.toString())

2、Trait
1. 概念理解
Scala Trait(特征) 至关于 Java 的接口，实际上它比接口还功能强大。
(1)与接口不一样的是，它还能够定义属性和方法的实现。
(2)通常状况下Scala的类能够继承多个Trait，从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类相似，但它使用的关键字是 trait。
(3)继承的多个trait中若是有同名的方法和属性，必需要在类中使用“override”从新定义。
(4)trait中不能够传参数并发

trait Read {
val readType = "Read"
val gender = "m"
def read(name:String){
println(name+" is reading")
}
}

trait Listen {
val listenType = "Listen"
val gender = "m"
def listen(name:String){
println(name + " is listenning")
}
}

class Person() extends Read with Listen{
override val gender = "f"
}

object test {
def main(args: Array[String]): Unit = {
val person = new Person()
person.read("zhangsan")
person.listen("lisi")
println(person.listenType)
println(person.readType)
println(person.gender)

}
}

trait中带方法能够不实现异步

object Lesson_Trait2 {
def main(args: Array[String]): Unit = {
val p1 = new Point(1,2)
val p2 = new Point(1,3)
println(p1.isEqule(p2))
println(p1.isNotEqule(p2))
}
}

trait Equle{
def isEqule(x:Any) :Boolean 
def isNotEqule(x : Any) = {
!isEqule(x)
}
}

class Point(x:Int, y:Int) extends Equle {
val xx = x
val yy = y

def isEqule(p:Any) = {
p.isInstanceOf[Point] && p.asInstanceOf[Point].xx==xx
}

}

3、模式匹配
(1)模式匹配不只能够匹配值还能够匹配类型
(2)从上到下顺序匹配，若是匹配到则再也不往下匹配
(3)都匹配不上时，会匹配到case _ ,至关于default
(4)match 的最外面的”{ }”能够去掉当作一个语句分布式

object Lesson_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())
}

}
/**
* 注意点：
* 1.模式匹配不只能够匹配值，还能够匹配类型
* 2.模式匹配中，若是匹配到对应的类型或值，就再也不继续往下匹配
* 3.模式匹配中，都匹配不上时，会匹配到 case _ ，至关于default
*/
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 x :Double => println("type is Double")
case _ => println("no match")
}
}

}

样例类
使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类。实现了类构造参数的getter方法（构造参数默认被声明为val），当构造参数是声明为var类型的，它将帮你实现setter和getter方法。
样例类默认帮你实现了toString,equals，copy和hashCode等方法。
样例类能够new, 也能够不用newide

case class Person1(name:String,age:Int)

object Lesson_CaseClass {
def main(args: Array[String]): Unit = {
val p1 = new Person1("zhangsan",10)
val p2 = Person1("lisi",20)
val p3 = Person1("wangwu",30)

val list = List(p1,p2,p3)
list.foreach { x => {
x match {
case Person1("zhangsan",10) => println("zhangsan")
case Person1("lisi",20) => println("lisi")
case _ => println("no match")
}
} }

}
}

4、Actor Model
Actor Model是用来编写并行计算或分布式系统的高层次抽象（相似java中的Thread）让程序员没必要为多线程模式下共享锁而烦恼,被用在Erlang 语言上, 高可用性99.9999999 % 一年只有31ms 宕机Actors将状态和行为封装在一个轻量的进程/线程中，可是不和其余Actors分享状态，每一个Actors有本身的世界观，当须要和其余Actors交互时，经过发送事件和消息，发送是异步的，非堵塞的(fire-andforget)，发送消息后没必要等另外Actors回复，也没必要暂停，每一个Actors有本身的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，能够创建性能很好的事件驱动系统。
Actor的特征：
 ActorModel是消息传递模型,基本特征就是消息传递
 消息发送是异步的，非阻塞的
 消息一旦发送成功，不能修改
 Actor之间传递时，本身决定决定去检查消息，而不是一直等待，是异步非阻塞的高并发

什么是Akka
Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和Scala 的 Actor 模型应用，底层实现就是Actor,Akka是一个开发库和运行环境，能够用于构建高并发、分布式、可容错、事件驱动的基于JVM的应用。使构建高并发的分布式应用更加容易。
spark1.6版本以前，spark分布式节点之间的消息传递使用的就是Akka，底层也就是actor实现的。1.6以后使用的netty传输。

package com.wjy

import scala.actors.Actor

class myActor extends Actor {

  def act() {
    while (true) {
      receive {
        case x: String => println("save String =" + x)
        case x: Int    => println("save Int")
        case _         => println("save default")
      }
    }
  }
}

object Lesson_Actor {
  def main(args: Array[String]): Unit = {

    //建立actor的消息接收和传递
    val actor = new myActor()
    //启动
    actor.start()
    //发送消息写法 actor空格!空格 "消息"
    actor ! "i love you !"

  }
}

Actor与Actor之间通讯

package com.wjy

import scala.actors.Actor

case class Message(actor: Actor, msg: Any)

class Actor1 extends Actor {
  def act() {
    while (true) {
      receive {
        case msg: Message => {
          println("i sava msg! = " + msg.msg)

          msg.actor ! "i love you too !"
        }
        case msg: String => println(msg)
        case _           => println("default msg!")
      }
    }
  }
}

class Actor2(actor: Actor) extends Actor {
  actor ! Message(this, "i love you !")
  def act() {
    while (true) {
      receive {
        case msg: String => {
          if (msg.equals("i love you too !")) {
            println(msg)
            actor ! "could we have a date !"
          }
        }
        case _ => println("default msg!")
      }
    }
  }
}

object Lesson_Actor2 {
  def main(args: Array[String]): Unit = {
    val actor1 = new Actor1()
    actor1.start()
    val actor2 = new Actor2(actor1)
    actor2.start()
  }
}