大数据实战第十二课之-Scala知识05

第一章：上次课回顾

第二章：Scala之模式匹配

• 2.1 Idea实现模式匹配匹配值
• 2.2 Idea实现模式匹配匹配类型

第三章：Scala之偏函数

第四章：Scala之元组

• 4.1 迭代元组
• 4.2 元组转为字符串
• 4.3 元素交换

第五章：本次课程涉及面试题

第一章、上次课回顾

https://blog.csdn.net/zhikanjiani/article/details/90350808

第二章、Scala之模式匹配

Scala提供了强大的模式匹配机制，应用非常广泛。

• 一个模式匹配包含了一系列备选项，每个都开始于关键字case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

    使用规则：match {
    case 值1 => 代码
    case 值2 => 代码
    case  _  =>	代码		//任何没有匹配上的都走最后一段代码
    }
  

需求及实现：

• 有三个老师，我们需要随机输出一个老师：

	val teachers = Array("大桥","京香","蒂亚")
    val teacher = teachers(Random.nextInt(teachers.length))     //数组里面随机取值

    println(teacher)

2.1、Scala模式匹配-匹配值

Scala中模式匹配（如下代码匹配的是值）：

package scala05

import scala.util.Random

object MatchApp {
  def main(args: Array[String]): Unit = {
    val teachers = Array("大桥","京香","蒂亚","樱木凛")
    val teacher = teachers(Random.nextInt(teachers.length))     //数组里面随机取值

    teacher match{
      case "大桥" => println("SMBD-115")
      case  "京香" => println("MIDE-345")
      case _ => println("EBOD-525、BBI-198")

    }
  }
}

2.2、Scala模式匹配-匹配类型

生产当中的模式匹配应用场景（scala异常处理） 匹配的是类型：

package scala05

object MatchApplication {

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


    try{
      val i = 1/0
    }catch{
      case e:ArithmeticException  => throw new RuntimeException("除数不能为0")
      case e:Exception => e.printStackTrace()
    }
    finally{
        println("finally")
    }
  }

}

一句话总结：

• 模式匹配既可以匹配类型，也可以匹配值

第三章、Scala之偏函数（PartialFunction）

在第二章中，我们定义了一个数组，在数组中抽取随机数，再使用match进行模式匹配。

首先定义一个模式匹配的函数，再定义了一个偏函数：如下代码进行对比：

package scala05

import scala.util.Random

object MatchApp {
  def main(args: Array[String]): Unit = {
    val teachers = Array("大桥","京香","蒂亚","樱木凛")
    val teacher = teachers(Random.nextInt(teachers.length))     //数组里面随机取值

	//最原始的模式匹配
    teacher match{
      case "大桥" => println("SMBD-115")
      case  "京香" => println("MIDE_345")
      case _ => println("EBOD-525、BBI-198")
    }

	//把模式匹配定义成为一个方法
    watch(teacher)
    def watch(name:String) = name match {
            case "大桥" => println("SMBD-115")
            case  "京香" => println("MIDE-345")
            case _ => println("EBOD-525、BBI-198")
    }

	//如下是偏函数
  watch2(teacher)
    def watch2:PartialFunction[String,String] = {
      case "大桥" => "SMBD-115"
      case  "京香" => "MIDE_345"
      case _ => "EBOD-525、BBI-198"
    }
  }
}

总结：

偏函数 PartialFunction{}大括号内饰没有case的一组语句。

第四章、Scala之tuple（元组）

• 与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。
• 元组的值是通过将单个的值包含在圆括号中构成的

举例：

• 如下实例是在元组中定义了三个元素，分别对应的类型为[Int,Double,java.lang.string].

    val t = (1,3.14,"Friend")
  

我们也可以更换定义的方式：

val t = new Tuple3(1,3.14,"Friend")

元组的实际类型取决于它的元素的类型，比如（99,“runoob”）是Tuple2[Int,String].

• 目前Scala支持的元组的最大长度为22，对于更大长度可以使用集合，或者扩展元组。

如何访问元组中的元素？

• 我们可以使用a._1访问第一个元素，t._2访问第二个元素，如下所示：

object Test {
	 def main(args: Array[String]): Unit = {
		val a = (10,20,30,40,50,60)
	
		val sum = a._1 + a._2 + a._3 + a._4 + a._5 + a._6
			println("元素之和为：" + sum)
	}
}

Tuple1：

• val a = (1,2,3,4,5,6)
  println(a._1)
  输出就是1

Tuple：

• val a = (sched,ts)
  a._1 得到sched
  a._2 得到ts

在SparkContext.scala中，找一个TaskScheduler

4.1 迭代元组

• 我们可以使用Tuple.productIterator()方法来迭代输出元组的所有元素：

object Test {
	def main(args: Array[String]) {
		val t = (4,3,2,1)
		t.productIterator.foreach{ i => println("value=" + i)}
	}
}

输出结果如下：
value = 4
value = 3
value = 2
value = 1

4.2 元组转为字符串

你可以使用Tuple.toString()方法来将元组的所有元素组合成一个字符串，实例如下：

object Test {
		def main(args: Array[String]) {
				val t = new Tuple3(1,"hello",Console)					//Tuple中的元素是3个，所以是Tuple3
	
				println("连接后的字符串为：" + t.toString() )
	}

}

输出结果如下：
连接后的字符串为：((1,hello,scala.Console$@59494225))

4.3 元素交换

• 我们可以使用Tuple.swap方法来交换元组的元素（仅限元组中的元素只有两个的时候）。如下实例：

object Test {
		def main(args: Array[String]) {
				val t = new tuple2("www.google.com","www.runoob.com")

				println("交换后的元组：" + t.swap)
	}
}

第五章、本次课程涉及的面试题

面试过程中，写一个模式匹配，但是不允许使用match，考察偏函数。