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

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

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

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

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

（x:Int）=> x + 1

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.toStringval b:(Int,Int) => String = (my1, my2) => "my int: " + my1.toStringvar c = (x:Int, y:Int) => "my int: " + x + ydef d(x: Int): String = {
"my:" + x
}

以上四个方式的最终调用方式均为：a/b/c/d(参数)
其中 a b c 相当于在变量上赋予了一个函数体，而 d 本身就是一个函数
b 有两个参数，调用是必须有两个 Int 类型的参数

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

冒号永远靠近集合类型

scala> List(1,2,3)
res2: List[Int] = List(1, 2, 3)scala> res2:+4
res3: List[Int] = List(1, 2, 3, 4)scala> 0+:res2
res4: List[Int] = List(0, 1, 2, 3)

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

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

用于集合遍历

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

用于返回一个二元元组

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))

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

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

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))
}

遍历集合筛选列表中大于某个值的元素

scala> val lst = List(1,2,3,4,5)
lst: List[Int] = List(1, 2, 3, 4, 5)scala> val lstFilter = lst.filter(_ > 3)
lstFilter: List[Int] = List(4, 5)

做参数的占位符

val f = _ + _

也可以用冒号来指定类型

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

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

scala> val m = Map(1->2, 2->4)
m: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 2 -> 4)scala> for((k,_) <- m) println(k)
1
2

//如果不需要所有部件，则在不需要的部件使用_；本例只取key，因此在value处用_

加不加空格都可以
对于Int类型来说它是0
对于Double来说，它是0.0
对于引用类型来说，它是null

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

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

为可变数组添加元素

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

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