【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.6

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個參數

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, 也能夠不用new

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