Scala基础三

一、集合的高阶函数

1.1 map

  map是对集合中的每一个元素都做相同的操作，返回一个新的集合。

常用的写法
1、a.map((x:Int) => x * 2)
2、a.map(x => x * 2)
3、a.map(_ * 2)  //_表示集合中的每一元素

1.2 foreach

  foreach是对集合进行一次操作，但不会返回新的集合，常用于控制台输出信息。

常用的写法
1、a.foreach(println(_))
2、a.foreach(println)

1.3 filter

  filter就是按照条件过滤集合数据，生成新的集合。

需要过滤出大于10的元素
a.filter(_ > 10)

1.4 take

  取集合的前n个元素的数据。

需要取前3个数据
a.take(3)

1.5 reduce

  对两两相邻数据元素做一次聚合操作，得到结果。

集合求和
a.reduce(_+_)  
//Left第一个_是上一次操作的结果（或第一个元素）,后一个_表示需要操作的元素
//Right第一个_是需要操作的元素，后一个_上一次操作的结果（或最后一个元素）

  有一个很有意思的事情，加法看不出来，但是减法很明显。

a.reduceLeft(_-_)
结果 -8
a.reduceRight(_-_)
结果 -2

  原因是应为减的顺序，一个是从左减，一个是从右减。

计算从左边开始
a.reduceLeft((a,b) => { 
  println(a+" "+b)
  a-b
})
结果
1 2    //a=1,b =2
-1 3    //a=上一次的结果 b=3
-4 4    //a=上一次的结果 b=4

计算从右边开始
a.reduceRight((a,b) => { 
  println(a+" "+b)
  a-b
})
结果
3 4   //a,b 从最右边两个开始，a=3,b =4
2 -1  //a=2 b=上一次的结果
1 3   //a=1 b=上一次的结果

1.5 count

  查询满足条件的元素个数

元素大于2有几个
a.count(_>2)

1.6 zip

  集合间的组装，以最小长度的集合为输出集合的长度。

val a = List(1,2,3,4)
var b = List("a","b","c","d","e")
a.zip(b)
结果
List[(Int, String)] = List((1,a), (2,b), (3,c), (4,d))

1.6 flatten

  打扁，将集合中的元素，扁平化成一个集合。

val f = List(List(1,2),List(3,4,5),List(6,7,8,9))
f.flatten
结果
List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

1.7 flatMap

  打扁，对每个元素进行操作。但是，但是flatMap(_)，这个_表示原元集。

val f = List(List(1,2),List(3,4,5),List(6,7,8,9))
f.flatMap(_.map(_ * 2)) //第一个_表示f中元素的类型
结果
List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18)

二、 tuple

  元组，就是一群数据的集合。val a=(1,2,3,4,”haha”)这个就是一个tuple，如何访问，a._1 a._2访问。

三、String

3.1 多行数据的字符串

val b = """
          | hello
          | 我
    """.stripMargin
println(b)
输出
  hello
  我

3.2 字符串拼接输出

  使用字符串插值，打印一句话：hello我

val wo ="我"
1、println("hello"+wo)   //传统输出方式
2、println(s"hello${wo}") //字符串插值输出

四、Currying

  本来方法使用参数都是写在一个方法内的，currying的方式就是将参数一个一个拆开写。在spark SQL UDF中常用如：

原来的写法：
def function(a:Int, b:String){}
currying写法：
def function(a:Int)(b:String){}
使用：
function(10)("hahaha")

五、异常处理

  Scala中的异常处理基本上和Java差不多。

    try {
      val a = 1 / 0
    } catch {
      case e: ArithmeticException =>
        println("0不能做分母")
        throw new RuntimeException("0不能做分母")
      case e: FileNotFoundException =>
        println("文件不存在")
        throw new RuntimeException("文件不存在")
      case e: Exception =>
        println("异常")
      case _ =>
        println("通用异常")
    } finally {
      println("finally")
    }

  异常处理中是一个模式匹配，只有当异常类型匹配相应catch中的出错类型，就会执行。所以不用调换位置进行排序。但是，但是，但是，_占位符比较麻烦，需要放到最后面，这样才能不被匹配，入股把_写在最开始，那其他的都不能被匹配。

六、模式匹配

  类似Java中switch，但是用途更广，不局限于基本类型。

val  teachers = Array("Yoshizawa Akiho", "Aoi sola", "Yui Hatano")
val teacher = teachers(Random.nextInt(teachers.length))
teacher match {
  case "Yoshizawa Akiho" =>
   println("吉老师")
  case "Aoi sola" =>
   println("仓老师")
  case "Yui Hatano" =>
   println("波老师")
  case _ =>
    println("不知道")
}

  比如用于数组：

def greet(array: Array[String]): Unit ={
  array match {
    case Array("hahaha") =>
      println("1")
    case Array(x,y) =>
      println("have two params")
    case Array("hahaha",_*) =>
      println("_*")
  }
greet(Array("hahaha","you"))
输出：
have two params

  上面这个方法就是将输入的参数进行匹配。可以稍加改动变成偏函数。什么是偏函数：被包在花括号内没有match的一组case语句。

def greet:PartialFunction[Array[String],Unit] ={
    case Array("hahaha") =>
      println("1")
    case Array(x,y) =>
      println("have two params")
    case Array("hahaha",_*) =>
      println("_*")
  }

  PartialFunction这个函数规定了方法greet的入参和出参。