date: 2019-08-01 11:15:27

updated: 2019-08-22 15:22:32

参考地址

1. :::

:::（三个冒号）只用于连接两个 List 类型的集合

val a = List(1, 2)
val b = List(3, 4)
val c = a ::: b

2. ::

::（两个冒号）表示普通元素与 List 的连接操作

val a = 1
val b = List(3, 4)
val c = 1 :: b

:: 是右侧对象的方法，即它是对象 b 的方法，而 :: 左侧的运算数是 :: 方法的参数，所以 1::b 的含义是 b.::(1)

3. =>

根据其不同数学含义，有不同的意义

3.1 值

匿名函数 or lamba 表达式，定义格式：(参数列表) => 函数体

(x: Int) => x + 1

3.2 类型

syntactic sugar 语法糖: 把需要的参数、类型、函数最简化，由编译器来解析（去糖化）

the type Int => String, is equivalent to the type Function1[Int,String] i.e. a function that takes an argument of type Int and returns a String.

val a: Int => String = myint => "my int : " + myint.toString;

val b: (Int, Int) => String = (my1, my2) => "my int : " + my1.toString;

var c = (x: Int, y:Int) => "my int : " + x + y

def d(x: Int): String = {
"my:" + x;
}

以上四个方式的最终调用方式均为：a/b/c/d(参数)

其中 a b c 相当于在变量上赋予了一个函数体，而 d 本身就是一个函数

b 有两个参数，调用是必须有两个 Int 类型的参数

4. :+ 和 +：

:+ 方法：用于在尾部追加元素

+: 方法：用于在头部追加元素

冒号永远靠近集合类型

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

scala> res1:+2
res2: List[Int] = List(1, 2, 3, 2)

scala> 3+:res1
res4: List[Int] = List(3, 1, 2, 3)

5. ++

用于连接两个 Seq，eg：列表、集合、字符串、Map etc

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

scala> a++List(4,5,6)
res7: List[Int] = List(1, 2, 3, 4, 5, 6)

6. <-

用于集合遍历

var arr = Array(1,2,3,4)
for (i <- arr) {
  println(i)
}

1
2
3
4

7. ->

用于返回一个二元元组

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

scala> var b = List(4,5,6)
b: List[Int] = List(4, 5, 6)

scala> val c = a -> b
c: (List[Int], List[Int]) = (List(1, 2, 3),List(4, 5, 6))

8. ++=

用于字符串拼接，+= 为可变数组添加元素，可以用来加数值也可以用来拼接字符串，取决于等式左边是什么类型，但是 ++= 只能拼接字符串

scala> var s:String = "a"
s: String = a
scala> s += "b"
scala> println(s)
ab
scala> s ++= "c"
scala> println(s)
abc

9. _

9.1 通配符

1. _ 可以起到类似于 * 作用的通配符：

   import org.apache.spark.SparkContext._ // 引入所有 jar 包

2. 模式匹配

表示完全不清楚的值的通配符

object MatchTest extends App {
  def matchTest(x: Int): String = x match {
    case 1 => "one"
    case 2 => "two"
    case _ => "many"
  }
  println(matchTest(3))
}

9.2 指代集合中的每一个元素

遍历集合筛选列表中大于某个值的元素
val lst = List(1,2,3,4,5)
val lstFilter = lst.filter(_ > 3)

当做参数的占位符时，编译器有可能会没有足够的信息推断缺少的参数类型。

val f = _ + _

这时，可以使用冒号来指定类型

val f = (_: Int) + (_: Int)

9.3 获取元组中指定下标的元素值

val ss = (1,"22","333")
println(ss._1)

9.4 使用模式匹配可以用来获取元组的组员

val m = Map(1 -> 2,2 -> 4)
for ((k,_) <- m) println(k)
//如果不需要所有部件， 则在不需要的部件使用 _ ；本例只取key,因此在value处用 _

9.5 代表某一类型的默认值

加不加空格都可以

对于Int类型来说，它是0

对于Double来说，它是0.0

对于引用类型来说，它是null

var s: Int = _
def main(args: Array[String]): Unit = {
    println(s)
}

9.6 :_* 作为一个整体，告诉编译器你希望将某个参数当做数序列处理

def main(args: Array[String]): Unit = {
    val s = sum(1 to 5 :_*)      //把1 to 5当作一个序列处理
    println(s)
}
def sum(args: Int*) : Int = {
    var result = 0 ;
    for(s2 <- args) {
      result += s2 ;
    }
    result ;
}

10. +=

为可变数组添加元素

11. -=

从可变数组中移除相应的值

var map = Map(1 -> 1,2 -> 2,3 ->3 )
map -= 1
结果：scala.collection.immutable.Map[Int,Int] = Map(2 -> 2, 3 -> 3)