Scala 符号

符号含义

泛型限定

泛型中的符号 <: >: <% : + -

符号 作用
[T <: UpperBound] 上界
[T >: LowerBound] 下界
[T <% ViewBound] 视界
[T : ContextBound] 上下文界
[+T] 协变
[-T] 逆变
参考：https://blog.csdn.net/datadev_sh/article/details/79589238#t4

eg: <:

我们定义一个类：“Earth”
class Earth {
  def sound(){
    println("hello !")
  }
}
 
我们定义了一个子类：“Animal”
class Animal extends Earth{ override def sound() ={ println("animal sound") } }
然后 ，还有Animal 的一个子类 “Bird”

class Bird extends Animal{ override def sound()={ print("bird sounds") } }
最后，又定义了一个函数：
 
def biophony[T <: Animal](things: Seq[T]) = things map (_.sound)
 
    “<:”是什么意思？

其实， 这属于Scala泛型中的知识：上边界和下边界。上边界是“<:”，下边界是“>:”；T <: Animal的意思是：T必须是Animal的子类。这样一来，我们再看看这个函数的意思：定义了一个叫“biophony”的函数，这个函数的参数必须传一个集合，一个什么样的集合呢？Animal 子类或者是Animal的集合（包含Animal）。函数右边就很好理解了，map中每个元素调用了sound方法。

知道了是什么之后，接着调用就很简单了：

 

  biophony(Seq(new Bird, new Bird))
————————————————
版权声明：本文为CSDN博主「菜刚」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/i6448038/java/article/details/52061287

集合操作符

:: +: :+ ++ ++: :::
这些符号全都是连接的作用，将元素与集合、集合与集合相连接

:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))。所以 :: +: :::这些操作符都是在前面插入（ ++: 除外，为什么？）。:+ ++ ++:这些是追加、拼接。

scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)

scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)
1
2
3
4
5
符号 操作 结果 位置 解释
:: a :: b List(List(1, 2, 3), 4, 5, 6) 前插 把a当成一个元素，前插到b集合
+: a +: b List(List(1, 2, 3), 4, 5, 6) 前插 同上
:+ a :+ b List(1, 2, 3, List(4, 5, 6)) 后插 把b当成一个元素，后插到a集合
++ a ++ b List(1, 2, 3, 4, 5, 6) 拼接 a和b集合顺序合并
++: a ++:b List(1, 2, 3, 4, 5, 6) 拼接 同上
::: a::::b List(1, 2, 3, 4, 5, 6) 拼接 同上
参考：https://blog.csdn.net/datadev_sh/article/details/79587108#t28

数学运算符

• • • / %

未分类

=>

定义函数， xxx => yyy 左边是函数变量，右边是函数返回值

<-

遍历中的<- 将变量赋给索引

for( i <- arrs )

->

->方法是所有Scala对象都有的方法，返回一个二元的元组(A,B)

scala> 1 -> 2
res9: (Int, Int) = (1,2)
1
2

神奇的下划线 _

参考：http://blog.csdn.net/i6448038/article/details/50017427

_N(下划线数字)

_N用于访问元组的第N个元素(N从1开始算起)。

val pair = (99, "Luftballons")  
println(pair._1)  
println(pair._2)  

————————————————
版权声明：本文为CSDN博主「datadev_sh」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/datadev_sh/java/article/details/79854273

模式匹配中使用 @

这个 @ 的主要功能是在模式匹配中，匹配到一个模式后，但是在处理过程中，使用对象本身而不是匹配后的元素。

案例1：匹配 Some()

参考该 Overflow 回答

当我们匹配对象是否为 Some(x) 的时候，如果没有 @ 那么最后我们在匹配中的值将是 Some(x) 中的 x， 而如果加入 @，那么最后匹配的将会是 Some(x)

It enables one to bind a matched pattern to a variable. Consider the following, for instance:

val o: Option[Int] = Some(2)

You can easily extract the content:

o match {
  case Some(x) => println(x)
  case None =>
}

But what if you wanted not the content of Some, but the option itself? That would be accomplished with this:

o match {
  case x @ Some(_) => println(x)
  case None =>
}

Note that @ can be used at any level, not just at the top level of the matching.

案例2：API 匹配 Request

def intent = {
 case req @ GET(Path(Seg("api" :: "user" :: IntPathElement(userId) :: Nil))) =>
      val f = (userManager ? FindUserById(userId))
      respond(f, req)
      
 case req @ GET(Path(Seg("api" :: "user" :: Nil))) & Params(EmailParam(email)) =>
      val f = (userManager ? FindUserByEmail(email))
      respond(f, req)  
}

在处理 request 请求的时候，需要匹配请求的路径，然后还需要直接使用 requet。

下划线 _ 的使用场景

import 通配符

import org.apache.spark.SparkContext._

集合操作指代每一个元素

在所有的集合操作中都可以使用下划线指代集合内容。

object Sample {
   def main (args: Array[String]){
    val newArry= (1 to 10).map(_*2)
   println(newArry)
   }
}

在一个 Array a中筛出偶数，并乘以2

a.filter(_%2==0).map(2*_)

模式匹配使用

主要用于匹配通配的情形

Some(5) match { case Some(_) => println("Yes") }
match {
     case List(1,_,_) => " a list with three element and the first element is 1"
     case List(_*)  => " a list with zero or more elements "
     case Map[_,_] => " matches a map with any key type and any value type "
     case _ =>
 }
val (a, _) = (1, 2)
for (_ <- 1 to 10)