Spark大数据分析与实战笔记（第一章 Scala语言基础-5）

每日一句正能量

“成功的秘诀，在于对目标的执着追求。”——爱迪生

无论是在工作、学习、还是生活中，只有对目标有着真正的执着追求，才有可能取得成功。爱迪生是个成功的发明家，也是一个努力不懈、坚持不断的实践者。他曾说过：“没有人能够一次成功，成功的秘诀就在于多次失败后依然不放弃对目标的执着追求。”

所以，只有对自己的目标有着强烈的追求，才能在取得成果的路上坚持不懈地去奋斗，才能不怕失败，不放弃，不断地提高自己的能力和技巧。每一次失败都是向成功更近一步的机会，只要时刻保持目标的执着追求，坚信自己一定能够取得成功，就一定会迈向胜利。

章节概要

Spark是专为大规模数据处理而设计的快速通用的计算引擎，它是由Scala语言开发实现的，关于大数据技术，本身就是计算数据，而Scala既有面向对象组织项目工程的能力，又具备计算数据的功能，同时Spark和Scala的紧密集成，本书将采用Scala语言开发Spark程序，所以学好Scala将有助于我们更好的掌握Spark框架。

1.5 Scala的模式匹配与样例类

Scala提供了强大的模式匹配机制，最常见的模式匹配就是math语句，主要应用于从多个分支中进行选择的场景。

1.5.1 模式匹配

• Scala中的模式匹配是由match case组成，它类似于Java中的switch case。
• match关键字主要用来描述一个表达式，位于表达式位置的后面。
• case关键字主要用来描述和表达式结果进行比较后的模式。

创建模式匹配的语法格式如下：

表达式 match {
	case 模式1 => 语句1
	case 模式2 => 语句2
	case 模式3 => 语句3
}

下面，定义一个方法matchTest()，方法的参数是一个整形字段，而方法的调用则是对参数进行模式匹配，若参数匹配的是1，则打印输出“one”；若参数匹配的是2，则打印输出“two”；若参数匹配的是_，则打印输出“many”，具体实现代码如下所示。

package cn.itcast.scala

object Ch12_PatternMatch {
  def main(args: Array[String]): Unit = {
    println(matchTest(5))
  }

  //模式匹配
  def matchTest(x:Int):String = x match{
    case 1 => "one"
    case 2 => "two"
    case _ => "many"
  }
}

结果如下图所示：

字符匹配

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

      val charStr = '6'

      charStr match {

        case '+' => println("匹配上了加号")

        case '-' => println("匹配上了减号")

        case '*' => println("匹配上了乘号")

        case '/' => println("匹配上了除号")

          //注意。所有的模式匹配都必须最终匹配上一个值，如果没有匹配上任何值，就会报错

       // case _  => println("都没有匹配上，我是默认值")

      }
    }

匹配字符串

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

      val arr = Array("hadoop", "zookeeper", "spark")

      val name = arr(Random.nextInt(arr.length))

      name match {

        case "hadoop"    => println("大数据分布式存储和计算框架...")

        case "zookeeper" => println("大数据分布式协调服务框架...")

        case "spark" => println("大数据分布式内存计算框架...")

        case _ => println("我不认识你...")

      }
  }

守卫

模式匹配当中，我们也可以通过条件进行判断

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

         var ch = "500"

         var sign = 0

         ch match {

         case "+" => sign = 1

         case "-" => sign = 2

         case _ if ch.equals("500") => sign = 3

         case _ => sign = 4

         }
         println(ch + " " + sign)
}

匹配类型

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

//注意泛型擦除，在模式匹配当中的类型匹配中，除了Array类型以为，所有的其他的数据类型都会被擦除掉

val a = 3

val obj = if(a == 1) 1

else if(a == 2) "2"

else if(a == 3) BigInt(3)

else if(a == 4) Map("aa" -> 1)

else if(a == 5) Map(1 -> "aa")

else if(a == 6) Array(1, 2, 3)

else if(a == 7) Array("aa", 1)

else if(a == 8) Array("aa")

val r1 = obj match {

case x: Int => x

case s: String => s.toInt

case BigInt => -1 //不能这么匹配

case _: BigInt => Int.MaxValue

case m: Map[String, Int] => "Map[String, Int]类型的Map集合"

case m: Map[_, _] => "Map集合"

case a: Array[Int] => "It's an Array[Int]"

case a: Array[String] => "It's an Array[String]"

case a: Array[_] => "It's an array of something other than Int"

case _ => 0

}

println(r1 + ", " + r1.getClass.getName)

}

匹配数组、元组、集合

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

val arr = Array(0, 3, 5)

arr match {

case Array(0, x, y) => println(x + " " + y)

case Array(0) => println("only 0")

//匹配数组以1 开始作为第一个元素

case Array(1, _*) => println("0 ...")

case _ => println("something else")

}

val lst = List(3, -1)

lst match {

case 0 :: Nil => println("only 0")

case x :: y :: Nil => println(s"x: $x y: $y")

case 0 :: tail => println("0 ...")

case _ => println("something else")

}

val tup = (1, 3, 7)

tup match {

case (1, x, y) => println(s"1, $x , $y")

case (_, z, 5) => println(z)

case _ => println("else")

	}
}

注意：在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。

9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表

注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

1.5.2 样例类

• 在Scala中，使用case关键字来定义的类被称为样例类。
• 样例类是一种特殊的类，经过优化可以被用于模式匹配。

样例类首先是类，除此之外它是为模式匹配而优化的类，样例类用case关键字进行声明。样例类主要是使用在我们后面的sparkSQL当中，通过样例类来映射我们的表当中的对象

定义形式：

• case class 类型，是多例的，后面要跟构造参数。形式如下。

 case class Student(name:String)

• case object 类型，是单例的。 形式如下。

case object Person

下面，使用case关键字来定义样例类Person，并将该样例类应用到模式匹配中，具体代码如下所示。

package cn.itcast.scala

object Ch13_CaseClass {
  //定义样例类
  case class Person(name:String,age:Int)

  def main(args: Array[String]): Unit = {
    //创建样例类对象
    val alice = new Person("Alice", 25)
    val bob = new Person("Bob", 32)
    val charlie = new Person("Charlie", 33)
    //val tom = Person("tom",26)  //这种方式创建也可以

    for(person <- List(alice,bob,charlie)){
      //模式匹配
      person  match {
        case Person("Alice",25) => println("Hi Alice")
        case Person("Bob", 32) => println("Hi Bob")
        case Person("Charlie", 33) => println("Hi Charlie")
        //找不到以上匹配时
        case Person(name,age) => println("Name:"+name+"\t"+"Age:"+age)
      }
    }
  }
}

结果如下图所示：

课外补充

偏函数

被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction[A, B]的一个实例，A代表输入参数类型，B代表返回结果类型，常用作输入模式匹配，偏函数最大的特点就是它只接受和处理其参数定义域的一个子集。

val func1: PartialFunction[String, Int] = {

      case "one" => 1

      case "two" => 2

      // case _ => -1

     }

      def func2(num: String) : Int = num match {

      case "one" => 1

      case "two" => 2

      case _ => -1

     }
       
     def main(args: Array[String]) {

      println(func1("one"))

      println(func2("one"))

      //如果偏函数当中没有匹配上，那么就会报错，我们可以通过isDefinedAt来进行判断

      // println(func1("three"))

      println(func1.isDefinedAt("three"))

      if(func1.isDefinedAt("three")){

      println("hello world")

      }else{

      println("world hello")

      }
}

转载自:https://blog.csdn.net/u014727709/article/details/133977059
欢迎start，欢迎评论，欢迎指正