大数据---------spark体系之分布式计算---------scala分布式编程开发语言----------scala中的match ，case class，actor

问题集锦：
01

---

目录

正文

01match

这个比较简单，如下

package com.bjsxt.scala

/**
  * 1. _=>是模式匹配中的默认匹配，放在最后
  * 2. 模式匹配不仅可以匹配值还可以匹配类型，使用时需要在类型前加一个形式变量。
  * 3. 匹配过程中会有值的自动转换，注意类型是不会转换的，比如如果值为1.0 那么不会和Int匹配。
  */
object Lesson_Match {
  def main(args:Array[String]): Unit ={
    val tple = (1,"hello",'c',1.0,true,1.1)
    val iter = tple.productIterator
    while(iter.hasNext){
      val one = iter.next()
      MatchTest(one)
    }
  }

  def MatchTest(o: Any): Unit ={
    o match {
      case 1 => println(1)
      // case 1.0=>println(1.0)
      case i:Int => println("Int")
      case _ => println("default")
    }
  }
}

2.case class

package com.bjsxt.scala

/**
  * case Class
  * 1.使用关键字case修饰的类叫做case类。构造参数默认被声明为val，此时它帮你实现了getter方法。
  * 当构造参数是声明为var类型的，它将帮你实现setter和getter方法。
  * 2.样例类默认帮你实现了toString,equals，copy和hashCode等方法，其中equals的区别如以下代码所示。
  * 3 样例类可以new, 也可以不用new
  * 4 由于样例类通常已经帮我们实现了各种方法，因此可以没有方法体。
  */

/**
  * 下面这段代码的输出是false，没有使用case关键字时，两个hunman实例时不同的。
  * @param name
  * @param age
  */
/*
class Human(name:String,age:Int){
  val this.name = name
  val this.age = age
}

object Lesson_caseClass {
  def main(args: Array[String]): Unit = {
    val human1 = new Human("zhengqiang",21)
    val human2 = new Human("zhengqiang", age = 21)
    println(human1.equals(human2))
  }
 }
*/

/**
  * 下面这段代码的输出为true。
  * @param name
  * @param age
  */
case class Human(name:String,age:Int)

object Lesson_caseClass {
  def main(args: Array[String]): Unit = {
    val human1 = new Human("zhengqiang",21)
    val human2 = new Human("zhengqiang", age = 21)
    println(human1.equals(human2))
  }
}

3 actor

这个比较复杂，第一段代码实现的功能是给新建的actor发送一句话。第二段代码实现的功能是actor之间的通信。第二段代码的功能也可以说成是实现了spark底层通信模型（面试有时会让写）。
第一段代码：

package com.bjsxt.scala

/**
  * actor是一种通信模型，Spark底层节点之间的通信用的是akka，Akka是通信模型，Akka是actor实现的。
  * actor类似于Thread
  */

import scala.actors.Actor

class MyActor() extends Actor {
  override def act(): Unit = {
    receive{
      case s:String => println("String")
      case _=>{println("default")}
    }
  }
}

object Lesson_Actor1 {
  def main(args: Array[String]): Unit = {
    val actor = new MyActor()
    actor.start()
    actor ! "hello"
  }
}

第二段代码：

package com.bjsxt.scala

/**
  * 问题集锦
  * 1.为啥给actor 传递的Message的参数是this  ? 这个问题是这段代码的重点。
  * 当actor2想给actor1发送消息时，只需要将actor1作为参数传递给actor2，然后在actor2的内部给actor1传递消息即可。
  * 但是当actor1想给actor2发送消息时却发现actor2此时没有定义。怎么解决这个问题呢
  * 这里采用的办法是将Actor和消息封装成一个Message类。这时，如果actor1想要发送消息给actor2,只需要将
  * /**actor1作为参数传递给actor2，并在actor2类内部将Message类的参数设为this，并发送给actor1。**/
  * 由于此时Message类的参数为this，即actor2，同时又将这个Message传递给了actor1，
  * 也就是说我们成功的将actor2传递给了actor1，然后在actor1的内部给actor2传递消息即可。
  */

import scala.actors.Actor

case class Message (actor:Actor,s:String)//为啥采用case类 因为这里不需要其他方法了。

class MyActor1() extends Actor(){

  override def act(): Unit = {
    while(true){
      receive {
        case mess:Message=>{
          if(mess.s.equals("Hello")){
            mess.actor ! "Hi"
          }
          else if(mess.s.equals("Could we have a data ?")){
            mess.actor ! "yes!"
          }
          else if(mess.s.equals("ok")){
            mess.actor ! "let's go"
          }
        }
        case _=>println("default")
      }
    }
  }
}

class MyActor2(actor:Actor)extends Actor {
  actor ! Message(this,"Hello")//1.为啥给actor1 传递的Message的参数是this
  override def act(): Unit = {
    receive {
      case s:String=>{
        if(s.equals("Hi")){
          actor ! Message(this,"Could we have a data ?")
        }
        else if(s.equals("yes!")){
          actor ! Message(this,"ok")
        }
      }
      case _=>println("default")
    }
  }
}

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

  }
}